From ff9679a130028784a7332d42adb28dd3c37cc746 Mon Sep 17 00:00:00 2001 From: GitHub Actions Date: Wed, 10 Jul 2024 19:58:11 +0000 Subject: [PATCH] update docs from 512e370 --- docs/assets/main.js | 7 +- docs/assets/navigation.js | 1 - docs/assets/search.js | 2 +- docs/assets/style.css | 47 +- docs/classes/Ix.AsyncIterable-1.html | 2752 ++++++++++++++++- docs/classes/Ix.Iterable-1.html | 2321 +++++++++++++- docs/functions/Ix.AsyncIterable.asyncify.html | 135 +- .../Ix.AsyncIterable.asyncifyErrback.html | 135 +- docs/functions/Ix.AsyncIterable.catchAll.html | 113 +- .../Ix.AsyncIterable.catchError.html | 113 +- .../Ix.AsyncIterable.combineLatest.html | 438 ++- docs/functions/Ix.AsyncIterable.concat.html | 409 ++- docs/functions/Ix.AsyncIterable.create.html | 124 +- docs/functions/Ix.AsyncIterable.defer.html | 124 +- docs/functions/Ix.AsyncIterable.empty.html | 95 +- docs/functions/Ix.AsyncIterable.forkJoin.html | 863 +++++- .../Ix.AsyncIterable.fromDOMStream.html | 151 +- .../functions/Ix.AsyncIterable.fromEvent.html | 182 +- .../Ix.AsyncIterable.fromEventPattern.html | 176 +- .../Ix.AsyncIterable.fromNodeStream.html | 110 +- docs/functions/Ix.AsyncIterable.generate.html | 176 +- .../Ix.AsyncIterable.generateTime.html | 195 +- docs/functions/Ix.AsyncIterable.iif.html | 136 +- docs/functions/Ix.AsyncIterable.merge.html | 444 ++- docs/functions/Ix.AsyncIterable.never.html | 95 +- docs/functions/Ix.AsyncIterable.of.html | 113 +- .../Ix.AsyncIterable.onErrorResumeNext.html | 113 +- docs/functions/Ix.AsyncIterable.race.html | 109 +- docs/functions/Ix.AsyncIterable.range.html | 110 +- .../Ix.AsyncIterable.repeatValue.html | 119 +- .../Ix.AsyncIterable.throwError.html | 104 +- docs/functions/Ix.AsyncIterable.whileDo.html | 127 +- docs/functions/Ix.AsyncIterable.zip.html | 438 ++- docs/functions/Ix.Iterable.catchAll.html | 97 +- docs/functions/Ix.Iterable.catchError.html | 97 +- docs/functions/Ix.Iterable.concat.html | 412 ++- docs/functions/Ix.Iterable.create.html | 103 +- docs/functions/Ix.Iterable.defer.html | 107 +- docs/functions/Ix.Iterable.empty.html | 83 +- docs/functions/Ix.Iterable.generate.html | 158 +- docs/functions/Ix.Iterable.iif.html | 115 +- docs/functions/Ix.Iterable.of.html | 101 +- .../Ix.Iterable.onErrorResumeNext.html | 97 +- docs/functions/Ix.Iterable.range.html | 98 +- docs/functions/Ix.Iterable.repeatValue.html | 107 +- docs/functions/Ix.Iterable.throwError.html | 97 +- docs/functions/Ix.Iterable.whileDo.html | 110 +- docs/functions/Ix.Iterable.zip.html | 426 ++- docs/functions/Ix_dom.fromDOMStream.html | 10 - docs/functions/Ix_node.fromNodeStream.html | 5 - docs/functions/asynciterable._concatAll.html | 120 +- docs/functions/asynciterable.as.html | 183 +- docs/functions/asynciterable.asyncify.html | 156 +- .../asynciterable.asyncifyErrback.html | 156 +- docs/functions/asynciterable.average.html | 166 +- .../asynciterable.combineLatest.html | 459 ++- docs/functions/asynciterable.concat.html | 430 ++- docs/functions/asynciterable.count.html | 140 +- docs/functions/asynciterable.create.html | 145 +- docs/functions/asynciterable.defer.html | 145 +- docs/functions/asynciterable.elementAt.html | 146 +- docs/functions/asynciterable.empty.html | 116 +- docs/functions/asynciterable.every.html | 140 +- docs/functions/asynciterable.find.html | 140 +- docs/functions/asynciterable.findIndex.html | 140 +- docs/functions/asynciterable.first.html | 136 +- docs/functions/asynciterable.forkJoin.html | 884 +++++- docs/functions/asynciterable.from.html | 141 +- docs/functions/asynciterable.fromEvent.html | 275 +- .../asynciterable.fromEventPattern.html | 197 +- docs/functions/asynciterable.generate.html | 197 +- .../functions/asynciterable.generateTime.html | 216 +- docs/functions/asynciterable.includes.html | 152 +- docs/functions/asynciterable.interval.html | 125 +- docs/functions/asynciterable.isEmpty.html | 140 +- docs/functions/asynciterable.last.html | 140 +- docs/functions/asynciterable.max.html | 142 +- docs/functions/asynciterable.maxBy.html | 146 +- docs/functions/asynciterable.merge.html | 465 ++- docs/functions/asynciterable.min.html | 142 +- docs/functions/asynciterable.minBy.html | 146 +- docs/functions/asynciterable.never.html | 116 +- .../asynciterable.onErrorResumeNext.html | 134 +- docs/functions/asynciterable.race.html | 130 +- docs/functions/asynciterable.range.html | 131 +- docs/functions/asynciterable.reduce.html | 146 +- docs/functions/asynciterable.reduceRight.html | 146 +- docs/functions/asynciterable.repeatValue.html | 140 +- .../asynciterable.sequenceEqual.html | 146 +- docs/functions/asynciterable.single.html | 140 +- docs/functions/asynciterable.some.html | 140 +- docs/functions/asynciterable.sum.html | 166 +- docs/functions/asynciterable.toArray.html | 140 +- docs/functions/asynciterable.toDOMStream.html | 192 +- .../asynciterable.toDOMStreamProto.html | 1 - docs/functions/asynciterable.toMap.html | 147 +- .../functions/asynciterable.toObservable.html | 134 +- docs/functions/asynciterable.toSet.html | 140 +- docs/functions/asynciterable.zip.html | 459 ++- .../asynciterable_operators.batch.html | 137 +- .../asynciterable_operators.buffer.html | 152 +- ...citerable_operators.bufferCountOrTime.html | 152 +- .../asynciterable_operators.catchError.html | 165 +- ...citerable_operators.combineLatestWith.html | 441 ++- .../asynciterable_operators.concatAll.html | 137 +- .../asynciterable_operators.concatMap.html | 158 +- .../asynciterable_operators.concatWith.html | 412 ++- .../asynciterable_operators.debounce.html | 146 +- ...synciterable_operators.defaultIfEmpty.html | 146 +- .../asynciterable_operators.delay.html | 146 +- .../asynciterable_operators.delayEach.html | 146 +- .../asynciterable_operators.distinct.html | 152 +- ...erable_operators.distinctUntilChanged.html | 152 +- .../asynciterable_operators.doWhile.html | 157 +- .../asynciterable_operators.endWith.html | 146 +- .../asynciterable_operators.except.html | 165 +- .../asynciterable_operators.expand.html | 159 +- .../asynciterable_operators.filter.html | 207 +- .../asynciterable_operators.finalize.html | 152 +- .../asynciterable_operators.flat.html | 160 +- .../asynciterable_operators.flatMap.html | 160 +- .../asynciterable_operators.groupBy.html | 238 +- .../asynciterable_operators.groupJoin.html | 223 +- ...synciterable_operators.ignoreElements.html | 137 +- .../asynciterable_operators.innerJoin.html | 223 +- .../asynciterable_operators.intersect.html | 165 +- .../asynciterable_operators.map.html | 173 +- .../asynciterable_operators.memoize.html | 198 +- .../asynciterable_operators.mergeAll.html | 149 +- .../asynciterable_operators.mergeWith.html | 445 ++- .../asynciterable_operators.orderBy.html | 182 +- ...citerable_operators.orderByDescending.html | 182 +- .../asynciterable_operators.pairwise.html | 137 +- .../asynciterable_operators.pluck.html | 152 +- .../asynciterable_operators.publish.html | 183 +- .../asynciterable_operators.raceWith.html | 142 +- .../asynciterable_operators.repeat.html | 146 +- .../asynciterable_operators.retry.html | 146 +- .../asynciterable_operators.reverse.html | 137 +- .../asynciterable_operators.scan.html | 152 +- .../asynciterable_operators.scanRight.html | 152 +- .../asynciterable_operators.share.html | 185 +- .../asynciterable_operators.skip.html | 146 +- .../asynciterable_operators.skipLast.html | 146 +- .../asynciterable_operators.skipUntil.html | 157 +- .../asynciterable_operators.skipWhile.html | 211 +- .../asynciterable_operators.slice.html | 152 +- .../asynciterable_operators.startWith.html | 162 +- .../asynciterable_operators.switchAll.html | 144 +- .../asynciterable_operators.switchMap.html | 158 +- .../asynciterable_operators.take.html | 146 +- .../asynciterable_operators.takeLast.html | 146 +- .../asynciterable_operators.takeUntil.html | 157 +- .../asynciterable_operators.takeWhile.html | 211 +- .../asynciterable_operators.tap.html | 187 +- .../asynciterable_operators.thenBy.html | 182 +- ...nciterable_operators.thenByDescending.html | 182 +- .../asynciterable_operators.throttle.html | 146 +- .../asynciterable_operators.timeInterval.html | 137 +- .../asynciterable_operators.timeout.html | 146 +- .../asynciterable_operators.timestamp.html | 137 +- .../asynciterable_operators.toDOMStream.html | 162 +- .../asynciterable_operators.union.html | 165 +- .../asynciterable_operators.withAbort.html | 146 +- ...synciterable_operators.withLatestFrom.html | 441 ++- ...asynciterable_operators.wrapWithAbort.html | 152 +- .../asynciterable_operators.zipWith.html | 441 ++- docs/functions/dom.fromDOMStream.html | 109 + docs/functions/iterable.as.html | 198 +- docs/functions/iterable.average.html | 152 +- docs/functions/iterable.concat.html | 441 ++- docs/functions/iterable.count.html | 126 +- docs/functions/iterable.create.html | 122 +- docs/functions/iterable.defer.html | 126 +- docs/functions/iterable.elementAt.html | 126 +- docs/functions/iterable.empty.html | 102 +- docs/functions/iterable.every.html | 126 +- docs/functions/iterable.find.html | 126 +- docs/functions/iterable.findIndex.html | 126 +- docs/functions/iterable.first.html | 122 +- docs/functions/iterable.from.html | 127 +- docs/functions/iterable.generate.html | 177 +- docs/functions/iterable.includes.html | 128 +- docs/functions/iterable.isEmpty.html | 120 +- docs/functions/iterable.last.html | 126 +- docs/functions/iterable.max.html | 128 +- docs/functions/iterable.maxBy.html | 132 +- docs/functions/iterable.min.html | 128 +- docs/functions/iterable.minBy.html | 132 +- .../functions/iterable.onErrorResumeNext.html | 116 +- docs/functions/iterable.range.html | 117 +- docs/functions/iterable.reduce.html | 168 +- docs/functions/iterable.reduceRight.html | 168 +- docs/functions/iterable.repeatValue.html | 126 +- docs/functions/iterable.sequenceEqual.html | 132 +- docs/functions/iterable.single.html | 126 +- docs/functions/iterable.some.html | 126 +- docs/functions/iterable.sum.html | 152 +- docs/functions/iterable.toArray.html | 120 +- docs/functions/iterable.toDOMStream.html | 142 +- docs/functions/iterable.toDOMStreamProto.html | 1 - docs/functions/iterable.toMap.html | 138 +- docs/functions/iterable.toSet.html | 120 +- docs/functions/iterable.zip.html | 445 ++- docs/functions/iterable_operators.buffer.html | 131 +- .../iterable_operators.catchError.html | 142 +- .../iterable_operators.concatAll.html | 116 +- .../iterable_operators.concatWith.html | 391 ++- .../iterable_operators.defaultIfEmpty.html | 125 +- .../iterable_operators.distinct.html | 131 +- ...erable_operators.distinctUntilChanged.html | 131 +- .../functions/iterable_operators.doWhile.html | 131 +- .../functions/iterable_operators.endWith.html | 125 +- docs/functions/iterable_operators.except.html | 144 +- docs/functions/iterable_operators.expand.html | 136 +- docs/functions/iterable_operators.filter.html | 186 +- .../iterable_operators.finalize.html | 131 +- docs/functions/iterable_operators.flat.html | 125 +- .../functions/iterable_operators.flatMap.html | 148 +- .../functions/iterable_operators.groupBy.html | 211 +- .../iterable_operators.groupJoin.html | 196 +- .../iterable_operators.ignoreElements.html | 116 +- .../iterable_operators.innerJoin.html | 196 +- .../iterable_operators.intersect.html | 144 +- docs/functions/iterable_operators.map.html | 150 +- .../functions/iterable_operators.memoize.html | 177 +- .../functions/iterable_operators.orderBy.html | 161 +- .../iterable_operators.orderByDescending.html | 161 +- .../iterable_operators.pairwise.html | 116 +- docs/functions/iterable_operators.pluck.html | 131 +- .../functions/iterable_operators.publish.html | 162 +- docs/functions/iterable_operators.repeat.html | 125 +- docs/functions/iterable_operators.retry.html | 125 +- .../functions/iterable_operators.reverse.html | 116 +- docs/functions/iterable_operators.scan.html | 165 +- .../iterable_operators.scanRight.html | 165 +- docs/functions/iterable_operators.share.html | 162 +- docs/functions/iterable_operators.skip.html | 125 +- .../iterable_operators.skipLast.html | 125 +- .../iterable_operators.skipWhile.html | 186 +- docs/functions/iterable_operators.slice.html | 131 +- .../iterable_operators.startWith.html | 125 +- docs/functions/iterable_operators.take.html | 125 +- .../iterable_operators.takeLast.html | 125 +- .../iterable_operators.takeWhile.html | 186 +- docs/functions/iterable_operators.tap.html | 166 +- docs/functions/iterable_operators.thenBy.html | 161 +- .../iterable_operators.thenByDescending.html | 161 +- .../iterable_operators.toDOMStream.html | 141 +- docs/functions/iterable_operators.union.html | 144 +- .../functions/iterable_operators.zipWith.html | 420 ++- docs/functions/node.fromNodeStream.html | 73 + docs/index.html | 77 +- docs/modules/Ix.AsyncIterable.html | 206 +- docs/modules/Ix.Iterable.html | 166 +- docs/modules/Ix.html | 65 +- docs/modules/Ix_dom.html | 4 - docs/modules/Ix_node.html | 4 - docs/modules/asynciterable.html | 164 +- docs/modules/asynciterable_operators.html | 124 +- docs/modules/dom.html | 76 + docs/modules/iterable.html | 145 +- docs/modules/iterable_operators.html | 103 +- docs/modules/node.html | 76 + 264 files changed, 45686 insertions(+), 2716 deletions(-) delete mode 100644 docs/assets/navigation.js delete mode 100644 docs/functions/Ix_dom.fromDOMStream.html delete mode 100644 docs/functions/Ix_node.fromNodeStream.html delete mode 100644 docs/functions/asynciterable.toDOMStreamProto.html create mode 100644 docs/functions/dom.fromDOMStream.html delete mode 100644 docs/functions/iterable.toDOMStreamProto.html create mode 100644 docs/functions/node.fromNodeStream.html delete mode 100644 docs/modules/Ix_dom.html delete mode 100644 docs/modules/Ix_node.html create mode 100644 docs/modules/dom.html create mode 100644 docs/modules/node.html diff --git a/docs/assets/main.js b/docs/assets/main.js index d0aa8d5f..4c8fa615 100644 --- a/docs/assets/main.js +++ b/docs/assets/main.js @@ -1,8 +1,7 @@ "use strict"; -"use strict";(()=>{var Pe=Object.create;var ne=Object.defineProperty;var Ie=Object.getOwnPropertyDescriptor;var Oe=Object.getOwnPropertyNames;var _e=Object.getPrototypeOf,Re=Object.prototype.hasOwnProperty;var Me=(t,e)=>()=>(e||t((e={exports:{}}).exports,e),e.exports);var Fe=(t,e,n,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of Oe(e))!Re.call(t,i)&&i!==n&&ne(t,i,{get:()=>e[i],enumerable:!(r=Ie(e,i))||r.enumerable});return t};var De=(t,e,n)=>(n=t!=null?Pe(_e(t)):{},Fe(e||!t||!t.__esModule?ne(n,"default",{value:t,enumerable:!0}):n,t));var ae=Me((se,oe)=>{(function(){var t=function(e){var n=new t.Builder;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),n.searchPipeline.add(t.stemmer),e.call(n,n),n.build()};t.version="2.3.9";t.utils={},t.utils.warn=function(e){return function(n){e.console&&console.warn&&console.warn(n)}}(this),t.utils.asString=function(e){return e==null?"":e.toString()},t.utils.clone=function(e){if(e==null)return e;for(var n=Object.create(null),r=Object.keys(e),i=0;i0){var d=t.utils.clone(n)||{};d.position=[a,u],d.index=s.length,s.push(new t.Token(r.slice(a,o),d))}a=o+1}}return s},t.tokenizer.separator=/[\s\-]+/;t.Pipeline=function(){this._stack=[]},t.Pipeline.registeredFunctions=Object.create(null),t.Pipeline.registerFunction=function(e,n){n in this.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[e.label]=e},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn(`Function is not registered with pipeline. This may cause problems when serialising the index. -`,e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(r){var i=t.Pipeline.registeredFunctions[r];if(i)n.add(i);else throw new Error("Cannot load unregistered function: "+r)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(n){t.Pipeline.warnIfFunctionNotRegistered(n),this._stack.push(n)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var r=this._stack.indexOf(e);if(r==-1)throw new Error("Cannot find existingFn");r=r+1,this._stack.splice(r,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var r=this._stack.indexOf(e);if(r==-1)throw new Error("Cannot find existingFn");this._stack.splice(r,0,n)},t.Pipeline.prototype.remove=function(e){var n=this._stack.indexOf(e);n!=-1&&this._stack.splice(n,1)},t.Pipeline.prototype.run=function(e){for(var n=this._stack.length,r=0;r1&&(oe&&(r=s),o!=e);)i=r-n,s=n+Math.floor(i/2),o=this.elements[s*2];if(o==e||o>e)return s*2;if(ol?d+=2:a==l&&(n+=r[u+1]*i[d+1],u+=2,d+=2);return n},t.Vector.prototype.similarity=function(e){return this.dot(e)/this.magnitude()||0},t.Vector.prototype.toArray=function(){for(var e=new Array(this.elements.length/2),n=1,r=0;n0){var o=s.str.charAt(0),a;o in s.node.edges?a=s.node.edges[o]:(a=new t.TokenSet,s.node.edges[o]=a),s.str.length==1&&(a.final=!0),i.push({node:a,editsRemaining:s.editsRemaining,str:s.str.slice(1)})}if(s.editsRemaining!=0){if("*"in s.node.edges)var l=s.node.edges["*"];else{var l=new t.TokenSet;s.node.edges["*"]=l}if(s.str.length==0&&(l.final=!0),i.push({node:l,editsRemaining:s.editsRemaining-1,str:s.str}),s.str.length>1&&i.push({node:s.node,editsRemaining:s.editsRemaining-1,str:s.str.slice(1)}),s.str.length==1&&(s.node.final=!0),s.str.length>=1){if("*"in s.node.edges)var u=s.node.edges["*"];else{var u=new t.TokenSet;s.node.edges["*"]=u}s.str.length==1&&(u.final=!0),i.push({node:u,editsRemaining:s.editsRemaining-1,str:s.str.slice(1)})}if(s.str.length>1){var d=s.str.charAt(0),v=s.str.charAt(1),f;v in s.node.edges?f=s.node.edges[v]:(f=new t.TokenSet,s.node.edges[v]=f),s.str.length==1&&(f.final=!0),i.push({node:f,editsRemaining:s.editsRemaining-1,str:d+s.str.slice(2)})}}}return r},t.TokenSet.fromString=function(e){for(var n=new t.TokenSet,r=n,i=0,s=e.length;i=e;n--){var r=this.uncheckedNodes[n],i=r.child.toString();i in this.minimizedNodes?r.parent.edges[r.char]=this.minimizedNodes[i]:(r.child._str=i,this.minimizedNodes[i]=r.child),this.uncheckedNodes.pop()}};t.Index=function(e){this.invertedIndex=e.invertedIndex,this.fieldVectors=e.fieldVectors,this.tokenSet=e.tokenSet,this.fields=e.fields,this.pipeline=e.pipeline},t.Index.prototype.search=function(e){return this.query(function(n){var r=new t.QueryParser(e,n);r.parse()})},t.Index.prototype.query=function(e){for(var n=new t.Query(this.fields),r=Object.create(null),i=Object.create(null),s=Object.create(null),o=Object.create(null),a=Object.create(null),l=0;l1?this._b=1:this._b=e},t.Builder.prototype.k1=function(e){this._k1=e},t.Builder.prototype.add=function(e,n){var r=e[this._ref],i=Object.keys(this._fields);this._documents[r]=n||{},this.documentCount+=1;for(var s=0;s=this.length)return t.QueryLexer.EOS;var e=this.str.charAt(this.pos);return this.pos+=1,e},t.QueryLexer.prototype.width=function(){return this.pos-this.start},t.QueryLexer.prototype.ignore=function(){this.start==this.pos&&(this.pos+=1),this.start=this.pos},t.QueryLexer.prototype.backup=function(){this.pos-=1},t.QueryLexer.prototype.acceptDigitRun=function(){var e,n;do e=this.next(),n=e.charCodeAt(0);while(n>47&&n<58);e!=t.QueryLexer.EOS&&this.backup()},t.QueryLexer.prototype.more=function(){return this.pos1&&(e.backup(),e.emit(t.QueryLexer.TERM)),e.ignore(),e.more())return t.QueryLexer.lexText},t.QueryLexer.lexEditDistance=function(e){return e.ignore(),e.acceptDigitRun(),e.emit(t.QueryLexer.EDIT_DISTANCE),t.QueryLexer.lexText},t.QueryLexer.lexBoost=function(e){return e.ignore(),e.acceptDigitRun(),e.emit(t.QueryLexer.BOOST),t.QueryLexer.lexText},t.QueryLexer.lexEOS=function(e){e.width()>0&&e.emit(t.QueryLexer.TERM)},t.QueryLexer.termSeparator=t.tokenizer.separator,t.QueryLexer.lexText=function(e){for(;;){var n=e.next();if(n==t.QueryLexer.EOS)return t.QueryLexer.lexEOS;if(n.charCodeAt(0)==92){e.escapeCharacter();continue}if(n==":")return t.QueryLexer.lexField;if(n=="~")return e.backup(),e.width()>0&&e.emit(t.QueryLexer.TERM),t.QueryLexer.lexEditDistance;if(n=="^")return e.backup(),e.width()>0&&e.emit(t.QueryLexer.TERM),t.QueryLexer.lexBoost;if(n=="+"&&e.width()===1||n=="-"&&e.width()===1)return e.emit(t.QueryLexer.PRESENCE),t.QueryLexer.lexText;if(n.match(t.QueryLexer.termSeparator))return t.QueryLexer.lexTerm}},t.QueryParser=function(e,n){this.lexer=new t.QueryLexer(e),this.query=n,this.currentClause={},this.lexemeIdx=0},t.QueryParser.prototype.parse=function(){this.lexer.run(),this.lexemes=this.lexer.lexemes;for(var e=t.QueryParser.parseClause;e;)e=e(this);return this.query},t.QueryParser.prototype.peekLexeme=function(){return this.lexemes[this.lexemeIdx]},t.QueryParser.prototype.consumeLexeme=function(){var e=this.peekLexeme();return this.lexemeIdx+=1,e},t.QueryParser.prototype.nextClause=function(){var e=this.currentClause;this.query.clause(e),this.currentClause={}},t.QueryParser.parseClause=function(e){var n=e.peekLexeme();if(n!=null)switch(n.type){case t.QueryLexer.PRESENCE:return t.QueryParser.parsePresence;case t.QueryLexer.FIELD:return t.QueryParser.parseField;case t.QueryLexer.TERM:return t.QueryParser.parseTerm;default:var r="expected either a field or a term, found "+n.type;throw n.str.length>=1&&(r+=" with value '"+n.str+"'"),new t.QueryParseError(r,n.start,n.end)}},t.QueryParser.parsePresence=function(e){var n=e.consumeLexeme();if(n!=null){switch(n.str){case"-":e.currentClause.presence=t.Query.presence.PROHIBITED;break;case"+":e.currentClause.presence=t.Query.presence.REQUIRED;break;default:var r="unrecognised presence operator'"+n.str+"'";throw new t.QueryParseError(r,n.start,n.end)}var i=e.peekLexeme();if(i==null){var r="expecting term or field, found nothing";throw new t.QueryParseError(r,n.start,n.end)}switch(i.type){case t.QueryLexer.FIELD:return t.QueryParser.parseField;case t.QueryLexer.TERM:return t.QueryParser.parseTerm;default:var r="expecting term or field, found '"+i.type+"'";throw new t.QueryParseError(r,i.start,i.end)}}},t.QueryParser.parseField=function(e){var n=e.consumeLexeme();if(n!=null){if(e.query.allFields.indexOf(n.str)==-1){var r=e.query.allFields.map(function(o){return"'"+o+"'"}).join(", "),i="unrecognised field '"+n.str+"', possible fields: "+r;throw new t.QueryParseError(i,n.start,n.end)}e.currentClause.fields=[n.str];var s=e.peekLexeme();if(s==null){var i="expecting term, found nothing";throw new t.QueryParseError(i,n.start,n.end)}switch(s.type){case t.QueryLexer.TERM:return t.QueryParser.parseTerm;default:var i="expecting term, found '"+s.type+"'";throw new t.QueryParseError(i,s.start,s.end)}}},t.QueryParser.parseTerm=function(e){var n=e.consumeLexeme();if(n!=null){e.currentClause.term=n.str.toLowerCase(),n.str.indexOf("*")!=-1&&(e.currentClause.usePipeline=!1);var r=e.peekLexeme();if(r==null){e.nextClause();return}switch(r.type){case t.QueryLexer.TERM:return e.nextClause(),t.QueryParser.parseTerm;case t.QueryLexer.FIELD:return e.nextClause(),t.QueryParser.parseField;case t.QueryLexer.EDIT_DISTANCE:return t.QueryParser.parseEditDistance;case t.QueryLexer.BOOST:return t.QueryParser.parseBoost;case t.QueryLexer.PRESENCE:return e.nextClause(),t.QueryParser.parsePresence;default:var i="Unexpected lexeme type '"+r.type+"'";throw new t.QueryParseError(i,r.start,r.end)}}},t.QueryParser.parseEditDistance=function(e){var n=e.consumeLexeme();if(n!=null){var r=parseInt(n.str,10);if(isNaN(r)){var i="edit distance must be numeric";throw new t.QueryParseError(i,n.start,n.end)}e.currentClause.editDistance=r;var s=e.peekLexeme();if(s==null){e.nextClause();return}switch(s.type){case t.QueryLexer.TERM:return e.nextClause(),t.QueryParser.parseTerm;case t.QueryLexer.FIELD:return e.nextClause(),t.QueryParser.parseField;case t.QueryLexer.EDIT_DISTANCE:return t.QueryParser.parseEditDistance;case t.QueryLexer.BOOST:return t.QueryParser.parseBoost;case t.QueryLexer.PRESENCE:return e.nextClause(),t.QueryParser.parsePresence;default:var i="Unexpected lexeme type '"+s.type+"'";throw new t.QueryParseError(i,s.start,s.end)}}},t.QueryParser.parseBoost=function(e){var n=e.consumeLexeme();if(n!=null){var r=parseInt(n.str,10);if(isNaN(r)){var i="boost must be numeric";throw new t.QueryParseError(i,n.start,n.end)}e.currentClause.boost=r;var s=e.peekLexeme();if(s==null){e.nextClause();return}switch(s.type){case t.QueryLexer.TERM:return e.nextClause(),t.QueryParser.parseTerm;case t.QueryLexer.FIELD:return e.nextClause(),t.QueryParser.parseField;case t.QueryLexer.EDIT_DISTANCE:return t.QueryParser.parseEditDistance;case t.QueryLexer.BOOST:return t.QueryParser.parseBoost;case t.QueryLexer.PRESENCE:return e.nextClause(),t.QueryParser.parsePresence;default:var i="Unexpected lexeme type '"+s.type+"'";throw new t.QueryParseError(i,s.start,s.end)}}},function(e,n){typeof define=="function"&&define.amd?define(n):typeof se=="object"?oe.exports=n():e.lunr=n()}(this,function(){return t})})()});var re=[];function G(t,e){re.push({selector:e,constructor:t})}var U=class{constructor(){this.alwaysVisibleMember=null;this.createComponents(document.body),this.ensureActivePageVisible(),this.ensureFocusedElementVisible(),this.listenForCodeCopies(),window.addEventListener("hashchange",()=>this.ensureFocusedElementVisible())}createComponents(e){re.forEach(n=>{e.querySelectorAll(n.selector).forEach(r=>{r.dataset.hasInstance||(new n.constructor({el:r,app:this}),r.dataset.hasInstance=String(!0))})})}filterChanged(){this.ensureFocusedElementVisible()}ensureActivePageVisible(){let e=document.querySelector(".tsd-navigation .current"),n=e?.parentElement;for(;n&&!n.classList.contains(".tsd-navigation");)n instanceof HTMLDetailsElement&&(n.open=!0),n=n.parentElement;if(e){let r=e.getBoundingClientRect().top-document.documentElement.clientHeight/4;document.querySelector(".site-menu").scrollTop=r}}ensureFocusedElementVisible(){if(this.alwaysVisibleMember&&(this.alwaysVisibleMember.classList.remove("always-visible"),this.alwaysVisibleMember.firstElementChild.remove(),this.alwaysVisibleMember=null),!location.hash)return;let e=document.getElementById(location.hash.substring(1));if(!e)return;let n=e.parentElement;for(;n&&n.tagName!=="SECTION";)n=n.parentElement;if(n&&n.offsetParent==null){this.alwaysVisibleMember=n,n.classList.add("always-visible");let r=document.createElement("p");r.classList.add("warning"),r.textContent="This member is normally hidden due to your filter settings.",n.prepend(r)}}listenForCodeCopies(){document.querySelectorAll("pre > button").forEach(e=>{let n;e.addEventListener("click",()=>{e.previousElementSibling instanceof HTMLElement&&navigator.clipboard.writeText(e.previousElementSibling.innerText.trim()),e.textContent="Copied!",e.classList.add("visible"),clearTimeout(n),n=setTimeout(()=>{e.classList.remove("visible"),n=setTimeout(()=>{e.textContent="Copy"},100)},1e3)})})}};var ie=(t,e=100)=>{let n;return()=>{clearTimeout(n),n=setTimeout(()=>t(),e)}};var de=De(ae());async function le(t,e){if(!window.searchData)return;let n=await fetch(window.searchData),r=new Blob([await n.arrayBuffer()]).stream().pipeThrough(new DecompressionStream("gzip")),i=await new Response(r).json();t.data=i,t.index=de.Index.load(i.index),e.classList.remove("loading"),e.classList.add("ready")}function he(){let t=document.getElementById("tsd-search");if(!t)return;let e={base:t.dataset.base+"/"},n=document.getElementById("tsd-search-script");t.classList.add("loading"),n&&(n.addEventListener("error",()=>{t.classList.remove("loading"),t.classList.add("failure")}),n.addEventListener("load",()=>{le(e,t)}),le(e,t));let r=document.querySelector("#tsd-search input"),i=document.querySelector("#tsd-search .results");if(!r||!i)throw new Error("The input field or the result list wrapper was not found");let s=!1;i.addEventListener("mousedown",()=>s=!0),i.addEventListener("mouseup",()=>{s=!1,t.classList.remove("has-focus")}),r.addEventListener("focus",()=>t.classList.add("has-focus")),r.addEventListener("blur",()=>{s||(s=!1,t.classList.remove("has-focus"))}),Ae(t,i,r,e)}function Ae(t,e,n,r){n.addEventListener("input",ie(()=>{Ne(t,e,n,r)},200));let i=!1;n.addEventListener("keydown",s=>{i=!0,s.key=="Enter"?Ve(e,n):s.key=="Escape"?n.blur():s.key=="ArrowUp"?ue(e,-1):s.key==="ArrowDown"?ue(e,1):i=!1}),n.addEventListener("keypress",s=>{i&&s.preventDefault()}),document.body.addEventListener("keydown",s=>{s.altKey||s.ctrlKey||s.metaKey||!n.matches(":focus")&&s.key==="/"&&(n.focus(),s.preventDefault())})}function Ne(t,e,n,r){if(!r.index||!r.data)return;e.textContent="";let i=n.value.trim(),s;if(i){let o=i.split(" ").map(a=>a.length?`*${a}*`:"").join(" ");s=r.index.search(o)}else s=[];for(let o=0;oa.score-o.score);for(let o=0,a=Math.min(10,s.length);o`,d=ce(l.name,i);globalThis.DEBUG_SEARCH_WEIGHTS&&(d+=` (score: ${s[o].score.toFixed(2)})`),l.parent&&(d=` - ${ce(l.parent,i)}.${d}`);let v=document.createElement("li");v.classList.value=l.classes??"";let f=document.createElement("a");f.href=r.base+l.url,f.innerHTML=u+d,v.append(f),e.appendChild(v)}}function ue(t,e){let n=t.querySelector(".current");if(!n)n=t.querySelector(e==1?"li:first-child":"li:last-child"),n&&n.classList.add("current");else{let r=n;if(e===1)do r=r.nextElementSibling??void 0;while(r instanceof HTMLElement&&r.offsetParent==null);else do r=r.previousElementSibling??void 0;while(r instanceof HTMLElement&&r.offsetParent==null);r&&(n.classList.remove("current"),r.classList.add("current"))}}function Ve(t,e){let n=t.querySelector(".current");if(n||(n=t.querySelector("li:first-child")),n){let r=n.querySelector("a");r&&(window.location.href=r.href),e.blur()}}function ce(t,e){if(e==="")return t;let n=t.toLocaleLowerCase(),r=e.toLocaleLowerCase(),i=[],s=0,o=n.indexOf(r);for(;o!=-1;)i.push(K(t.substring(s,o)),`${K(t.substring(o,o+r.length))}`),s=o+r.length,o=n.indexOf(r,s);return i.push(K(t.substring(s))),i.join("")}var Be={"&":"&","<":"<",">":">","'":"'",'"':"""};function K(t){return t.replace(/[&<>"'"]/g,e=>Be[e])}var C=class{constructor(e){this.el=e.el,this.app=e.app}};var F="mousedown",pe="mousemove",B="mouseup",J={x:0,y:0},fe=!1,ee=!1,He=!1,D=!1,me=/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);document.documentElement.classList.add(me?"is-mobile":"not-mobile");me&&"ontouchstart"in document.documentElement&&(He=!0,F="touchstart",pe="touchmove",B="touchend");document.addEventListener(F,t=>{ee=!0,D=!1;let e=F=="touchstart"?t.targetTouches[0]:t;J.y=e.pageY||0,J.x=e.pageX||0});document.addEventListener(pe,t=>{if(ee&&!D){let e=F=="touchstart"?t.targetTouches[0]:t,n=J.x-(e.pageX||0),r=J.y-(e.pageY||0);D=Math.sqrt(n*n+r*r)>10}});document.addEventListener(B,()=>{ee=!1});document.addEventListener("click",t=>{fe&&(t.preventDefault(),t.stopImmediatePropagation(),fe=!1)});var X=class extends C{constructor(n){super(n);this.className=this.el.dataset.toggle||"",this.el.addEventListener(B,r=>this.onPointerUp(r)),this.el.addEventListener("click",r=>r.preventDefault()),document.addEventListener(F,r=>this.onDocumentPointerDown(r)),document.addEventListener(B,r=>this.onDocumentPointerUp(r))}setActive(n){if(this.active==n)return;this.active=n,document.documentElement.classList.toggle("has-"+this.className,n),this.el.classList.toggle("active",n);let r=(this.active?"to-has-":"from-has-")+this.className;document.documentElement.classList.add(r),setTimeout(()=>document.documentElement.classList.remove(r),500)}onPointerUp(n){D||(this.setActive(!0),n.preventDefault())}onDocumentPointerDown(n){if(this.active){if(n.target.closest(".col-sidebar, .tsd-filter-group"))return;this.setActive(!1)}}onDocumentPointerUp(n){if(!D&&this.active&&n.target.closest(".col-sidebar")){let r=n.target.closest("a");if(r){let i=window.location.href;i.indexOf("#")!=-1&&(i=i.substring(0,i.indexOf("#"))),r.href.substring(0,i.length)==i&&setTimeout(()=>this.setActive(!1),250)}}}};var te;try{te=localStorage}catch{te={getItem(){return null},setItem(){}}}var Q=te;var ve=document.head.appendChild(document.createElement("style"));ve.dataset.for="filters";var Y=class extends C{constructor(n){super(n);this.key=`filter-${this.el.name}`,this.value=this.el.checked,this.el.addEventListener("change",()=>{this.setLocalStorage(this.el.checked)}),this.setLocalStorage(this.fromLocalStorage()),ve.innerHTML+=`html:not(.${this.key}) .tsd-is-${this.el.name} { display: none; } -`}fromLocalStorage(){let n=Q.getItem(this.key);return n?n==="true":this.el.checked}setLocalStorage(n){Q.setItem(this.key,n.toString()),this.value=n,this.handleValueChange()}handleValueChange(){this.el.checked=this.value,document.documentElement.classList.toggle(this.key,this.value),this.app.filterChanged(),document.querySelectorAll(".tsd-index-section").forEach(n=>{n.style.display="block";let r=Array.from(n.querySelectorAll(".tsd-index-link")).every(i=>i.offsetParent==null);n.style.display=r?"none":"block"})}};var Z=class extends C{constructor(n){super(n);this.summary=this.el.querySelector(".tsd-accordion-summary"),this.icon=this.summary.querySelector("svg"),this.key=`tsd-accordion-${this.summary.dataset.key??this.summary.textContent.trim().replace(/\s+/g,"-").toLowerCase()}`;let r=Q.getItem(this.key);this.el.open=r?r==="true":this.el.open,this.el.addEventListener("toggle",()=>this.update());let i=this.summary.querySelector("a");i&&i.addEventListener("click",()=>{location.assign(i.href)}),this.update()}update(){this.icon.style.transform=`rotate(${this.el.open?0:-90}deg)`,Q.setItem(this.key,this.el.open.toString())}};function ge(t){let e=Q.getItem("tsd-theme")||"os";t.value=e,ye(e),t.addEventListener("change",()=>{Q.setItem("tsd-theme",t.value),ye(t.value)})}function ye(t){document.documentElement.dataset.theme=t}var Le;function be(){let t=document.getElementById("tsd-nav-script");t&&(t.addEventListener("load",xe),xe())}async function xe(){let t=document.getElementById("tsd-nav-container");if(!t||!window.navigationData)return;let n=await(await fetch(window.navigationData)).arrayBuffer(),r=new Blob([n]).stream().pipeThrough(new DecompressionStream("gzip")),i=await new Response(r).json();Le=t.dataset.base+"/",t.innerHTML="";for(let s of i)we(s,t,[]);window.app.createComponents(t),window.app.ensureActivePageVisible()}function we(t,e,n){let r=e.appendChild(document.createElement("li"));if(t.children){let i=[...n,t.text],s=r.appendChild(document.createElement("details"));s.className=t.class?`${t.class} tsd-index-accordion`:"tsd-index-accordion",s.dataset.key=i.join("$");let o=s.appendChild(document.createElement("summary"));o.className="tsd-accordion-summary",o.innerHTML='',Ee(t,o);let a=s.appendChild(document.createElement("div"));a.className="tsd-accordion-details";let l=a.appendChild(document.createElement("ul"));l.className="tsd-nested-navigation";for(let u of t.children)we(u,l,i)}else Ee(t,r,t.class)}function Ee(t,e,n){if(t.path){let r=e.appendChild(document.createElement("a"));r.href=Le+t.path,n&&(r.className=n),location.href===r.href&&r.classList.add("current"),t.kind&&(r.innerHTML=``),r.appendChild(document.createElement("span")).textContent=t.text}else e.appendChild(document.createElement("span")).textContent=t.text}G(X,"a[data-toggle]");G(Z,".tsd-index-accordion");G(Y,".tsd-filter-item input[type=checkbox]");var Se=document.getElementById("tsd-theme");Se&&ge(Se);var je=new U;Object.defineProperty(window,"app",{value:je});he();be();})(); +"use strict";(()=>{var Se=Object.create;var re=Object.defineProperty;var we=Object.getOwnPropertyDescriptor;var Te=Object.getOwnPropertyNames;var ke=Object.getPrototypeOf,Qe=Object.prototype.hasOwnProperty;var Pe=(t,e)=>()=>(e||t((e={exports:{}}).exports,e),e.exports);var Ie=(t,e,r,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of Te(e))!Qe.call(t,i)&&i!==r&&re(t,i,{get:()=>e[i],enumerable:!(n=we(e,i))||n.enumerable});return t};var Ce=(t,e,r)=>(r=t!=null?Se(ke(t)):{},Ie(e||!t||!t.__esModule?re(r,"default",{value:t,enumerable:!0}):r,t));var ae=Pe((se,oe)=>{(function(){var t=function(e){var r=new t.Builder;return r.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),r.searchPipeline.add(t.stemmer),e.call(r,r),r.build()};t.version="2.3.9";t.utils={},t.utils.warn=function(e){return function(r){e.console&&console.warn&&console.warn(r)}}(this),t.utils.asString=function(e){return e==null?"":e.toString()},t.utils.clone=function(e){if(e==null)return e;for(var r=Object.create(null),n=Object.keys(e),i=0;i0){var d=t.utils.clone(r)||{};d.position=[a,u],d.index=s.length,s.push(new t.Token(n.slice(a,o),d))}a=o+1}}return s},t.tokenizer.separator=/[\s\-]+/;t.Pipeline=function(){this._stack=[]},t.Pipeline.registeredFunctions=Object.create(null),t.Pipeline.registerFunction=function(e,r){r in this.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+r),e.label=r,t.Pipeline.registeredFunctions[e.label]=e},t.Pipeline.warnIfFunctionNotRegistered=function(e){var r=e.label&&e.label in this.registeredFunctions;r||t.utils.warn(`Function is not registered with pipeline. This may cause problems when serialising the index. +`,e)},t.Pipeline.load=function(e){var r=new t.Pipeline;return e.forEach(function(n){var i=t.Pipeline.registeredFunctions[n];if(i)r.add(i);else throw new Error("Cannot load unregistered function: "+n)}),r},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(r){t.Pipeline.warnIfFunctionNotRegistered(r),this._stack.push(r)},this)},t.Pipeline.prototype.after=function(e,r){t.Pipeline.warnIfFunctionNotRegistered(r);var n=this._stack.indexOf(e);if(n==-1)throw new Error("Cannot find existingFn");n=n+1,this._stack.splice(n,0,r)},t.Pipeline.prototype.before=function(e,r){t.Pipeline.warnIfFunctionNotRegistered(r);var n=this._stack.indexOf(e);if(n==-1)throw new Error("Cannot find existingFn");this._stack.splice(n,0,r)},t.Pipeline.prototype.remove=function(e){var r=this._stack.indexOf(e);r!=-1&&this._stack.splice(r,1)},t.Pipeline.prototype.run=function(e){for(var r=this._stack.length,n=0;n1&&(oe&&(n=s),o!=e);)i=n-r,s=r+Math.floor(i/2),o=this.elements[s*2];if(o==e||o>e)return s*2;if(ol?d+=2:a==l&&(r+=n[u+1]*i[d+1],u+=2,d+=2);return r},t.Vector.prototype.similarity=function(e){return this.dot(e)/this.magnitude()||0},t.Vector.prototype.toArray=function(){for(var e=new Array(this.elements.length/2),r=1,n=0;r0){var o=s.str.charAt(0),a;o in s.node.edges?a=s.node.edges[o]:(a=new t.TokenSet,s.node.edges[o]=a),s.str.length==1&&(a.final=!0),i.push({node:a,editsRemaining:s.editsRemaining,str:s.str.slice(1)})}if(s.editsRemaining!=0){if("*"in s.node.edges)var l=s.node.edges["*"];else{var l=new t.TokenSet;s.node.edges["*"]=l}if(s.str.length==0&&(l.final=!0),i.push({node:l,editsRemaining:s.editsRemaining-1,str:s.str}),s.str.length>1&&i.push({node:s.node,editsRemaining:s.editsRemaining-1,str:s.str.slice(1)}),s.str.length==1&&(s.node.final=!0),s.str.length>=1){if("*"in s.node.edges)var u=s.node.edges["*"];else{var u=new t.TokenSet;s.node.edges["*"]=u}s.str.length==1&&(u.final=!0),i.push({node:u,editsRemaining:s.editsRemaining-1,str:s.str.slice(1)})}if(s.str.length>1){var d=s.str.charAt(0),m=s.str.charAt(1),y;m in s.node.edges?y=s.node.edges[m]:(y=new t.TokenSet,s.node.edges[m]=y),s.str.length==1&&(y.final=!0),i.push({node:y,editsRemaining:s.editsRemaining-1,str:d+s.str.slice(2)})}}}return n},t.TokenSet.fromString=function(e){for(var r=new t.TokenSet,n=r,i=0,s=e.length;i=e;r--){var n=this.uncheckedNodes[r],i=n.child.toString();i in this.minimizedNodes?n.parent.edges[n.char]=this.minimizedNodes[i]:(n.child._str=i,this.minimizedNodes[i]=n.child),this.uncheckedNodes.pop()}};t.Index=function(e){this.invertedIndex=e.invertedIndex,this.fieldVectors=e.fieldVectors,this.tokenSet=e.tokenSet,this.fields=e.fields,this.pipeline=e.pipeline},t.Index.prototype.search=function(e){return this.query(function(r){var n=new t.QueryParser(e,r);n.parse()})},t.Index.prototype.query=function(e){for(var r=new t.Query(this.fields),n=Object.create(null),i=Object.create(null),s=Object.create(null),o=Object.create(null),a=Object.create(null),l=0;l1?this._b=1:this._b=e},t.Builder.prototype.k1=function(e){this._k1=e},t.Builder.prototype.add=function(e,r){var n=e[this._ref],i=Object.keys(this._fields);this._documents[n]=r||{},this.documentCount+=1;for(var s=0;s=this.length)return t.QueryLexer.EOS;var e=this.str.charAt(this.pos);return this.pos+=1,e},t.QueryLexer.prototype.width=function(){return this.pos-this.start},t.QueryLexer.prototype.ignore=function(){this.start==this.pos&&(this.pos+=1),this.start=this.pos},t.QueryLexer.prototype.backup=function(){this.pos-=1},t.QueryLexer.prototype.acceptDigitRun=function(){var e,r;do e=this.next(),r=e.charCodeAt(0);while(r>47&&r<58);e!=t.QueryLexer.EOS&&this.backup()},t.QueryLexer.prototype.more=function(){return this.pos1&&(e.backup(),e.emit(t.QueryLexer.TERM)),e.ignore(),e.more())return t.QueryLexer.lexText},t.QueryLexer.lexEditDistance=function(e){return e.ignore(),e.acceptDigitRun(),e.emit(t.QueryLexer.EDIT_DISTANCE),t.QueryLexer.lexText},t.QueryLexer.lexBoost=function(e){return e.ignore(),e.acceptDigitRun(),e.emit(t.QueryLexer.BOOST),t.QueryLexer.lexText},t.QueryLexer.lexEOS=function(e){e.width()>0&&e.emit(t.QueryLexer.TERM)},t.QueryLexer.termSeparator=t.tokenizer.separator,t.QueryLexer.lexText=function(e){for(;;){var r=e.next();if(r==t.QueryLexer.EOS)return t.QueryLexer.lexEOS;if(r.charCodeAt(0)==92){e.escapeCharacter();continue}if(r==":")return t.QueryLexer.lexField;if(r=="~")return e.backup(),e.width()>0&&e.emit(t.QueryLexer.TERM),t.QueryLexer.lexEditDistance;if(r=="^")return e.backup(),e.width()>0&&e.emit(t.QueryLexer.TERM),t.QueryLexer.lexBoost;if(r=="+"&&e.width()===1||r=="-"&&e.width()===1)return e.emit(t.QueryLexer.PRESENCE),t.QueryLexer.lexText;if(r.match(t.QueryLexer.termSeparator))return t.QueryLexer.lexTerm}},t.QueryParser=function(e,r){this.lexer=new t.QueryLexer(e),this.query=r,this.currentClause={},this.lexemeIdx=0},t.QueryParser.prototype.parse=function(){this.lexer.run(),this.lexemes=this.lexer.lexemes;for(var e=t.QueryParser.parseClause;e;)e=e(this);return this.query},t.QueryParser.prototype.peekLexeme=function(){return this.lexemes[this.lexemeIdx]},t.QueryParser.prototype.consumeLexeme=function(){var e=this.peekLexeme();return this.lexemeIdx+=1,e},t.QueryParser.prototype.nextClause=function(){var e=this.currentClause;this.query.clause(e),this.currentClause={}},t.QueryParser.parseClause=function(e){var r=e.peekLexeme();if(r!=null)switch(r.type){case t.QueryLexer.PRESENCE:return t.QueryParser.parsePresence;case t.QueryLexer.FIELD:return t.QueryParser.parseField;case t.QueryLexer.TERM:return t.QueryParser.parseTerm;default:var n="expected either a field or a term, found "+r.type;throw r.str.length>=1&&(n+=" with value '"+r.str+"'"),new t.QueryParseError(n,r.start,r.end)}},t.QueryParser.parsePresence=function(e){var r=e.consumeLexeme();if(r!=null){switch(r.str){case"-":e.currentClause.presence=t.Query.presence.PROHIBITED;break;case"+":e.currentClause.presence=t.Query.presence.REQUIRED;break;default:var n="unrecognised presence operator'"+r.str+"'";throw new t.QueryParseError(n,r.start,r.end)}var i=e.peekLexeme();if(i==null){var n="expecting term or field, found nothing";throw new t.QueryParseError(n,r.start,r.end)}switch(i.type){case t.QueryLexer.FIELD:return t.QueryParser.parseField;case t.QueryLexer.TERM:return t.QueryParser.parseTerm;default:var n="expecting term or field, found '"+i.type+"'";throw new t.QueryParseError(n,i.start,i.end)}}},t.QueryParser.parseField=function(e){var r=e.consumeLexeme();if(r!=null){if(e.query.allFields.indexOf(r.str)==-1){var n=e.query.allFields.map(function(o){return"'"+o+"'"}).join(", "),i="unrecognised field '"+r.str+"', possible fields: "+n;throw new t.QueryParseError(i,r.start,r.end)}e.currentClause.fields=[r.str];var s=e.peekLexeme();if(s==null){var i="expecting term, found nothing";throw new t.QueryParseError(i,r.start,r.end)}switch(s.type){case t.QueryLexer.TERM:return t.QueryParser.parseTerm;default:var i="expecting term, found '"+s.type+"'";throw new t.QueryParseError(i,s.start,s.end)}}},t.QueryParser.parseTerm=function(e){var r=e.consumeLexeme();if(r!=null){e.currentClause.term=r.str.toLowerCase(),r.str.indexOf("*")!=-1&&(e.currentClause.usePipeline=!1);var n=e.peekLexeme();if(n==null){e.nextClause();return}switch(n.type){case t.QueryLexer.TERM:return e.nextClause(),t.QueryParser.parseTerm;case t.QueryLexer.FIELD:return e.nextClause(),t.QueryParser.parseField;case t.QueryLexer.EDIT_DISTANCE:return t.QueryParser.parseEditDistance;case t.QueryLexer.BOOST:return t.QueryParser.parseBoost;case t.QueryLexer.PRESENCE:return e.nextClause(),t.QueryParser.parsePresence;default:var i="Unexpected lexeme type '"+n.type+"'";throw new t.QueryParseError(i,n.start,n.end)}}},t.QueryParser.parseEditDistance=function(e){var r=e.consumeLexeme();if(r!=null){var n=parseInt(r.str,10);if(isNaN(n)){var i="edit distance must be numeric";throw new t.QueryParseError(i,r.start,r.end)}e.currentClause.editDistance=n;var s=e.peekLexeme();if(s==null){e.nextClause();return}switch(s.type){case t.QueryLexer.TERM:return e.nextClause(),t.QueryParser.parseTerm;case t.QueryLexer.FIELD:return e.nextClause(),t.QueryParser.parseField;case t.QueryLexer.EDIT_DISTANCE:return t.QueryParser.parseEditDistance;case t.QueryLexer.BOOST:return t.QueryParser.parseBoost;case t.QueryLexer.PRESENCE:return e.nextClause(),t.QueryParser.parsePresence;default:var i="Unexpected lexeme type '"+s.type+"'";throw new t.QueryParseError(i,s.start,s.end)}}},t.QueryParser.parseBoost=function(e){var r=e.consumeLexeme();if(r!=null){var n=parseInt(r.str,10);if(isNaN(n)){var i="boost must be numeric";throw new t.QueryParseError(i,r.start,r.end)}e.currentClause.boost=n;var s=e.peekLexeme();if(s==null){e.nextClause();return}switch(s.type){case t.QueryLexer.TERM:return e.nextClause(),t.QueryParser.parseTerm;case t.QueryLexer.FIELD:return e.nextClause(),t.QueryParser.parseField;case t.QueryLexer.EDIT_DISTANCE:return t.QueryParser.parseEditDistance;case t.QueryLexer.BOOST:return t.QueryParser.parseBoost;case t.QueryLexer.PRESENCE:return e.nextClause(),t.QueryParser.parsePresence;default:var i="Unexpected lexeme type '"+s.type+"'";throw new t.QueryParseError(i,s.start,s.end)}}},function(e,r){typeof define=="function"&&define.amd?define(r):typeof se=="object"?oe.exports=r():e.lunr=r()}(this,function(){return t})})()});var ne=[];function G(t,e){ne.push({selector:e,constructor:t})}var U=class{constructor(){this.alwaysVisibleMember=null;this.createComponents(document.body),this.ensureActivePageVisible(),this.ensureFocusedElementVisible(),this.listenForCodeCopies(),window.addEventListener("hashchange",()=>this.ensureFocusedElementVisible())}createComponents(e){ne.forEach(r=>{e.querySelectorAll(r.selector).forEach(n=>{n.dataset.hasInstance||(new r.constructor({el:n,app:this}),n.dataset.hasInstance=String(!0))})})}filterChanged(){this.ensureFocusedElementVisible()}ensureActivePageVisible(){let e=document.querySelector(".tsd-navigation .current"),r=e?.parentElement;for(;r&&!r.classList.contains(".tsd-navigation");)r instanceof HTMLDetailsElement&&(r.open=!0),r=r.parentElement;if(e){let n=e.getBoundingClientRect().top-document.documentElement.clientHeight/4;document.querySelector(".site-menu").scrollTop=n}}ensureFocusedElementVisible(){if(this.alwaysVisibleMember&&(this.alwaysVisibleMember.classList.remove("always-visible"),this.alwaysVisibleMember.firstElementChild.remove(),this.alwaysVisibleMember=null),!location.hash)return;let e=document.getElementById(location.hash.substring(1));if(!e)return;let r=e.parentElement;for(;r&&r.tagName!=="SECTION";)r=r.parentElement;if(r&&r.offsetParent==null){this.alwaysVisibleMember=r,r.classList.add("always-visible");let n=document.createElement("p");n.classList.add("warning"),n.textContent="This member is normally hidden due to your filter settings.",r.prepend(n)}}listenForCodeCopies(){document.querySelectorAll("pre > button").forEach(e=>{let r;e.addEventListener("click",()=>{e.previousElementSibling instanceof HTMLElement&&navigator.clipboard.writeText(e.previousElementSibling.innerText.trim()),e.textContent="Copied!",e.classList.add("visible"),clearTimeout(r),r=setTimeout(()=>{e.classList.remove("visible"),r=setTimeout(()=>{e.textContent="Copy"},100)},1e3)})})}};var ie=(t,e=100)=>{let r;return()=>{clearTimeout(r),r=setTimeout(()=>t(),e)}};var ce=Ce(ae());function de(){let t=document.getElementById("tsd-search");if(!t)return;let e=document.getElementById("tsd-search-script");t.classList.add("loading"),e&&(e.addEventListener("error",()=>{t.classList.remove("loading"),t.classList.add("failure")}),e.addEventListener("load",()=>{t.classList.remove("loading"),t.classList.add("ready")}),window.searchData&&t.classList.remove("loading"));let r=document.querySelector("#tsd-search input"),n=document.querySelector("#tsd-search .results");if(!r||!n)throw new Error("The input field or the result list wrapper was not found");let i=!1;n.addEventListener("mousedown",()=>i=!0),n.addEventListener("mouseup",()=>{i=!1,t.classList.remove("has-focus")}),r.addEventListener("focus",()=>t.classList.add("has-focus")),r.addEventListener("blur",()=>{i||(i=!1,t.classList.remove("has-focus"))});let s={base:t.dataset.base+"/"};Oe(t,n,r,s)}function Oe(t,e,r,n){r.addEventListener("input",ie(()=>{Re(t,e,r,n)},200));let i=!1;r.addEventListener("keydown",s=>{i=!0,s.key=="Enter"?Fe(e,r):s.key=="Escape"?r.blur():s.key=="ArrowUp"?ue(e,-1):s.key==="ArrowDown"?ue(e,1):i=!1}),r.addEventListener("keypress",s=>{i&&s.preventDefault()}),document.body.addEventListener("keydown",s=>{s.altKey||s.ctrlKey||s.metaKey||!r.matches(":focus")&&s.key==="/"&&(r.focus(),s.preventDefault())})}function _e(t,e){t.index||window.searchData&&(e.classList.remove("loading"),e.classList.add("ready"),t.data=window.searchData,t.index=ce.Index.load(window.searchData.index))}function Re(t,e,r,n){if(_e(n,t),!n.index||!n.data)return;e.textContent="";let i=r.value.trim(),s=i?n.index.search(`*${i}*`):[];for(let o=0;oa.score-o.score);for(let o=0,a=Math.min(10,s.length);o${le(l.parent,i)}.${u}`);let d=document.createElement("li");d.classList.value=l.classes??"";let m=document.createElement("a");m.href=n.base+l.url,m.innerHTML=u,d.append(m),e.appendChild(d)}}function ue(t,e){let r=t.querySelector(".current");if(!r)r=t.querySelector(e==1?"li:first-child":"li:last-child"),r&&r.classList.add("current");else{let n=r;if(e===1)do n=n.nextElementSibling??void 0;while(n instanceof HTMLElement&&n.offsetParent==null);else do n=n.previousElementSibling??void 0;while(n instanceof HTMLElement&&n.offsetParent==null);n&&(r.classList.remove("current"),n.classList.add("current"))}}function Fe(t,e){let r=t.querySelector(".current");if(r||(r=t.querySelector("li:first-child")),r){let n=r.querySelector("a");n&&(window.location.href=n.href),e.blur()}}function le(t,e){if(e==="")return t;let r=t.toLocaleLowerCase(),n=e.toLocaleLowerCase(),i=[],s=0,o=r.indexOf(n);for(;o!=-1;)i.push(K(t.substring(s,o)),`${K(t.substring(o,o+n.length))}`),s=o+n.length,o=r.indexOf(n,s);return i.push(K(t.substring(s))),i.join("")}var Me={"&":"&","<":"<",">":">","'":"'",'"':"""};function K(t){return t.replace(/[&<>"'"]/g,e=>Me[e])}var P=class{constructor(e){this.el=e.el,this.app=e.app}};var M="mousedown",fe="mousemove",N="mouseup",J={x:0,y:0},he=!1,ee=!1,De=!1,D=!1,pe=/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);document.documentElement.classList.add(pe?"is-mobile":"not-mobile");pe&&"ontouchstart"in document.documentElement&&(De=!0,M="touchstart",fe="touchmove",N="touchend");document.addEventListener(M,t=>{ee=!0,D=!1;let e=M=="touchstart"?t.targetTouches[0]:t;J.y=e.pageY||0,J.x=e.pageX||0});document.addEventListener(fe,t=>{if(ee&&!D){let e=M=="touchstart"?t.targetTouches[0]:t,r=J.x-(e.pageX||0),n=J.y-(e.pageY||0);D=Math.sqrt(r*r+n*n)>10}});document.addEventListener(N,()=>{ee=!1});document.addEventListener("click",t=>{he&&(t.preventDefault(),t.stopImmediatePropagation(),he=!1)});var X=class extends P{constructor(r){super(r);this.className=this.el.dataset.toggle||"",this.el.addEventListener(N,n=>this.onPointerUp(n)),this.el.addEventListener("click",n=>n.preventDefault()),document.addEventListener(M,n=>this.onDocumentPointerDown(n)),document.addEventListener(N,n=>this.onDocumentPointerUp(n))}setActive(r){if(this.active==r)return;this.active=r,document.documentElement.classList.toggle("has-"+this.className,r),this.el.classList.toggle("active",r);let n=(this.active?"to-has-":"from-has-")+this.className;document.documentElement.classList.add(n),setTimeout(()=>document.documentElement.classList.remove(n),500)}onPointerUp(r){D||(this.setActive(!0),r.preventDefault())}onDocumentPointerDown(r){if(this.active){if(r.target.closest(".col-sidebar, .tsd-filter-group"))return;this.setActive(!1)}}onDocumentPointerUp(r){if(!D&&this.active&&r.target.closest(".col-sidebar")){let n=r.target.closest("a");if(n){let i=window.location.href;i.indexOf("#")!=-1&&(i=i.substring(0,i.indexOf("#"))),n.href.substring(0,i.length)==i&&setTimeout(()=>this.setActive(!1),250)}}}};var te;try{te=localStorage}catch{te={getItem(){return null},setItem(){}}}var Q=te;var me=document.head.appendChild(document.createElement("style"));me.dataset.for="filters";var Y=class extends P{constructor(r){super(r);this.key=`filter-${this.el.name}`,this.value=this.el.checked,this.el.addEventListener("change",()=>{this.setLocalStorage(this.el.checked)}),this.setLocalStorage(this.fromLocalStorage()),me.innerHTML+=`html:not(.${this.key}) .tsd-is-${this.el.name} { display: none; } +`}fromLocalStorage(){let r=Q.getItem(this.key);return r?r==="true":this.el.checked}setLocalStorage(r){Q.setItem(this.key,r.toString()),this.value=r,this.handleValueChange()}handleValueChange(){this.el.checked=this.value,document.documentElement.classList.toggle(this.key,this.value),this.app.filterChanged(),document.querySelectorAll(".tsd-index-section").forEach(r=>{r.style.display="block";let n=Array.from(r.querySelectorAll(".tsd-index-link")).every(i=>i.offsetParent==null);r.style.display=n?"none":"block"})}};var Z=class extends P{constructor(r){super(r);this.summary=this.el.querySelector(".tsd-accordion-summary"),this.icon=this.summary.querySelector("svg"),this.key=`tsd-accordion-${this.summary.dataset.key??this.summary.textContent.trim().replace(/\s+/g,"-").toLowerCase()}`;let n=Q.getItem(this.key);this.el.open=n?n==="true":this.el.open,this.el.addEventListener("toggle",()=>this.update()),this.update()}update(){this.icon.style.transform=`rotate(${this.el.open?0:-90}deg)`,Q.setItem(this.key,this.el.open.toString())}};function ve(t){let e=Q.getItem("tsd-theme")||"os";t.value=e,ye(e),t.addEventListener("change",()=>{Q.setItem("tsd-theme",t.value),ye(t.value)})}function ye(t){document.documentElement.dataset.theme=t}de();G(X,"a[data-toggle]");G(Z,".tsd-index-accordion");G(Y,".tsd-filter-item input[type=checkbox]");var ge=document.getElementById("tsd-theme");ge&&ve(ge);var Ae=new U;Object.defineProperty(window,"app",{value:Ae});document.querySelectorAll("summary a").forEach(t=>{t.addEventListener("click",()=>{location.assign(t.href)})});})(); /*! Bundled license information: lunr/lunr.js: diff --git a/docs/assets/navigation.js b/docs/assets/navigation.js deleted file mode 100644 index 3ef5724d..00000000 --- a/docs/assets/navigation.js +++ /dev/null @@ -1 +0,0 @@ -window.navigationData = "data:application/octet-stream;base64,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" \ No newline at end of file diff --git a/docs/assets/search.js b/docs/assets/search.js index bec52b9c..dec39c3c 100644 --- a/docs/assets/search.js +++ b/docs/assets/search.js @@ -1 +1 @@ -window.searchData = "data:application/octet-stream;base64,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"; \ No newline at end of file +window.searchData = JSON.parse("{\"rows\":[{\"kind\":2,\"name\":\"Ix\",\"url\":\"modules/Ix.html\",\"classes\":\"\"},{\"kind\":2,\"name\":\"dom\",\"url\":\"modules/dom.html\",\"classes\":\"\"},{\"kind\":2,\"name\":\"node\",\"url\":\"modules/node.html\",\"classes\":\"\"},{\"kind\":2,\"name\":\"iterable\",\"url\":\"modules/iterable.html\",\"classes\":\"\"},{\"kind\":2,\"name\":\"iterable/operators\",\"url\":\"modules/iterable_operators.html\",\"classes\":\"\"},{\"kind\":2,\"name\":\"asynciterable\",\"url\":\"modules/asynciterable.html\",\"classes\":\"\"},{\"kind\":2,\"name\":\"asynciterable/operators\",\"url\":\"modules/asynciterable_operators.html\",\"classes\":\"\"},{\"kind\":128,\"name\":\"Iterable\",\"url\":\"classes/Ix.Iterable-1.html\",\"classes\":\"\",\"parent\":\"Ix\"},{\"kind\":2048,\"name\":\"as\",\"url\":\"classes/Ix.Iterable-1.html#as\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":2048,\"name\":\"from\",\"url\":\"classes/Ix.Iterable-1.html#from\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":512,\"name\":\"constructor\",\"url\":\"classes/Ix.Iterable-1.html#constructor\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":2048,\"name\":\"forEach\",\"url\":\"classes/Ix.Iterable-1.html#forEach\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":2048,\"name\":\"pipe\",\"url\":\"classes/Ix.Iterable-1.html#pipe\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":1024,\"name\":\"toDOMStream\",\"url\":\"classes/Ix.Iterable-1.html#toDOMStream\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#toDOMStream.__type-86\",\"classes\":\"\",\"parent\":\"Ix.Iterable.toDOMStream\"},{\"kind\":2048,\"name\":\"tee\",\"url\":\"classes/Ix.Iterable-1.html#tee\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":2048,\"name\":\"pipeTo\",\"url\":\"classes/Ix.Iterable-1.html#pipeTo\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":2048,\"name\":\"pipeThrough\",\"url\":\"classes/Ix.Iterable-1.html#pipeThrough\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":1024,\"name\":\"toNodeStream\",\"url\":\"classes/Ix.Iterable-1.html#toNodeStream\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#toNodeStream.__type-91\",\"classes\":\"\",\"parent\":\"Ix.Iterable.toNodeStream\"},{\"kind\":1024,\"name\":\"average\",\"url\":\"classes/Ix.Iterable-1.html#average\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#average.__type\",\"classes\":\"\",\"parent\":\"Ix.Iterable.average\"},{\"kind\":1024,\"name\":\"buffer\",\"url\":\"classes/Ix.Iterable-1.html#buffer\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#buffer.__type-3\",\"classes\":\"\",\"parent\":\"Ix.Iterable.buffer\"},{\"kind\":1024,\"name\":\"catchError\",\"url\":\"classes/Ix.Iterable-1.html#catchError\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#catchError.__type-4\",\"classes\":\"\",\"parent\":\"Ix.Iterable.catchError\"},{\"kind\":1024,\"name\":\"concatAll\",\"url\":\"classes/Ix.Iterable-1.html#concatAll\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#concatAll.__type-7\",\"classes\":\"\",\"parent\":\"Ix.Iterable.concatAll\"},{\"kind\":1024,\"name\":\"concat\",\"url\":\"classes/Ix.Iterable-1.html#concat\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#concat.__type-5\",\"classes\":\"\",\"parent\":\"Ix.Iterable.concat\"},{\"kind\":1024,\"name\":\"count\",\"url\":\"classes/Ix.Iterable-1.html#count\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#count.__type-8\",\"classes\":\"\",\"parent\":\"Ix.Iterable.count\"},{\"kind\":1024,\"name\":\"defaultIfEmpty\",\"url\":\"classes/Ix.Iterable-1.html#defaultIfEmpty\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#defaultIfEmpty.__type-9\",\"classes\":\"\",\"parent\":\"Ix.Iterable.defaultIfEmpty\"},{\"kind\":1024,\"name\":\"distinct\",\"url\":\"classes/Ix.Iterable-1.html#distinct\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#distinct.__type-10\",\"classes\":\"\",\"parent\":\"Ix.Iterable.distinct\"},{\"kind\":1024,\"name\":\"distinctUntilChanged\",\"url\":\"classes/Ix.Iterable-1.html#distinctUntilChanged\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#distinctUntilChanged.__type-11\",\"classes\":\"\",\"parent\":\"Ix.Iterable.distinctUntilChanged\"},{\"kind\":1024,\"name\":\"doWhile\",\"url\":\"classes/Ix.Iterable-1.html#doWhile\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#doWhile.__type-12\",\"classes\":\"\",\"parent\":\"Ix.Iterable.doWhile\"},{\"kind\":1024,\"name\":\"elementAt\",\"url\":\"classes/Ix.Iterable-1.html#elementAt\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#elementAt.__type-13\",\"classes\":\"\",\"parent\":\"Ix.Iterable.elementAt\"},{\"kind\":1024,\"name\":\"endWith\",\"url\":\"classes/Ix.Iterable-1.html#endWith\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#endWith.__type-14\",\"classes\":\"\",\"parent\":\"Ix.Iterable.endWith\"},{\"kind\":1024,\"name\":\"every\",\"url\":\"classes/Ix.Iterable-1.html#every\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#every.__type-15\",\"classes\":\"\",\"parent\":\"Ix.Iterable.every\"},{\"kind\":1024,\"name\":\"except\",\"url\":\"classes/Ix.Iterable-1.html#except\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#except.__type-16\",\"classes\":\"\",\"parent\":\"Ix.Iterable.except\"},{\"kind\":1024,\"name\":\"expand\",\"url\":\"classes/Ix.Iterable-1.html#expand\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#expand.__type-17\",\"classes\":\"\",\"parent\":\"Ix.Iterable.expand\"},{\"kind\":1024,\"name\":\"filter\",\"url\":\"classes/Ix.Iterable-1.html#filter\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#filter.__type-18\",\"classes\":\"\",\"parent\":\"Ix.Iterable.filter\"},{\"kind\":1024,\"name\":\"finally\",\"url\":\"classes/Ix.Iterable-1.html#finally\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#finally.__type-20\",\"classes\":\"\",\"parent\":\"Ix.Iterable.finally\"},{\"kind\":1024,\"name\":\"findIndex\",\"url\":\"classes/Ix.Iterable-1.html#findIndex\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#findIndex.__type-22\",\"classes\":\"\",\"parent\":\"Ix.Iterable.findIndex\"},{\"kind\":1024,\"name\":\"find\",\"url\":\"classes/Ix.Iterable-1.html#find\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#find.__type-21\",\"classes\":\"\",\"parent\":\"Ix.Iterable.find\"},{\"kind\":1024,\"name\":\"first\",\"url\":\"classes/Ix.Iterable-1.html#first\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#first.__type-23\",\"classes\":\"\",\"parent\":\"Ix.Iterable.first\"},{\"kind\":1024,\"name\":\"flatMap\",\"url\":\"classes/Ix.Iterable-1.html#flatMap\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#flatMap.__type-25\",\"classes\":\"\",\"parent\":\"Ix.Iterable.flatMap\"},{\"kind\":1024,\"name\":\"flat\",\"url\":\"classes/Ix.Iterable-1.html#flat\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#flat.__type-24\",\"classes\":\"\",\"parent\":\"Ix.Iterable.flat\"},{\"kind\":1024,\"name\":\"groupBy\",\"url\":\"classes/Ix.Iterable-1.html#groupBy\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#groupBy.__type-26\",\"classes\":\"\",\"parent\":\"Ix.Iterable.groupBy\"},{\"kind\":1024,\"name\":\"groupJoin\",\"url\":\"classes/Ix.Iterable-1.html#groupJoin\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#groupJoin.__type-29\",\"classes\":\"\",\"parent\":\"Ix.Iterable.groupJoin\"},{\"kind\":1024,\"name\":\"ignoreElements\",\"url\":\"classes/Ix.Iterable-1.html#ignoreElements\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#ignoreElements.__type-30\",\"classes\":\"\",\"parent\":\"Ix.Iterable.ignoreElements\"},{\"kind\":1024,\"name\":\"includes\",\"url\":\"classes/Ix.Iterable-1.html#includes\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#includes.__type-31\",\"classes\":\"\",\"parent\":\"Ix.Iterable.includes\"},{\"kind\":1024,\"name\":\"innerJoin\",\"url\":\"classes/Ix.Iterable-1.html#innerJoin\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#innerJoin.__type-32\",\"classes\":\"\",\"parent\":\"Ix.Iterable.innerJoin\"},{\"kind\":1024,\"name\":\"intersect\",\"url\":\"classes/Ix.Iterable-1.html#intersect\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#intersect.__type-33\",\"classes\":\"\",\"parent\":\"Ix.Iterable.intersect\"},{\"kind\":1024,\"name\":\"isEmpty\",\"url\":\"classes/Ix.Iterable-1.html#isEmpty\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#isEmpty.__type-34\",\"classes\":\"\",\"parent\":\"Ix.Iterable.isEmpty\"},{\"kind\":1024,\"name\":\"last\",\"url\":\"classes/Ix.Iterable-1.html#last\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#last.__type-35\",\"classes\":\"\",\"parent\":\"Ix.Iterable.last\"},{\"kind\":1024,\"name\":\"map\",\"url\":\"classes/Ix.Iterable-1.html#map\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#map.__type-36\",\"classes\":\"\",\"parent\":\"Ix.Iterable.map\"},{\"kind\":1024,\"name\":\"maxBy\",\"url\":\"classes/Ix.Iterable-1.html#maxBy\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#maxBy.__type-39\",\"classes\":\"\",\"parent\":\"Ix.Iterable.maxBy\"},{\"kind\":1024,\"name\":\"max\",\"url\":\"classes/Ix.Iterable-1.html#max\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#max.__type-37\",\"classes\":\"\",\"parent\":\"Ix.Iterable.max\"},{\"kind\":1024,\"name\":\"memoize\",\"url\":\"classes/Ix.Iterable-1.html#memoize\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#memoize.__type-40\",\"classes\":\"\",\"parent\":\"Ix.Iterable.memoize\"},{\"kind\":1024,\"name\":\"minBy\",\"url\":\"classes/Ix.Iterable-1.html#minBy\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#minBy.__type-44\",\"classes\":\"\",\"parent\":\"Ix.Iterable.minBy\"},{\"kind\":1024,\"name\":\"min\",\"url\":\"classes/Ix.Iterable-1.html#min\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#min.__type-43\",\"classes\":\"\",\"parent\":\"Ix.Iterable.min\"},{\"kind\":1024,\"name\":\"onErrorResumeNext\",\"url\":\"classes/Ix.Iterable-1.html#onErrorResumeNext\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#onErrorResumeNext.__type-45\",\"classes\":\"\",\"parent\":\"Ix.Iterable.onErrorResumeNext\"},{\"kind\":1024,\"name\":\"orderBy\",\"url\":\"classes/Ix.Iterable-1.html#orderBy\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#orderBy.__type-46\",\"classes\":\"\",\"parent\":\"Ix.Iterable.orderBy\"},{\"kind\":1024,\"name\":\"orderByDescending\",\"url\":\"classes/Ix.Iterable-1.html#orderByDescending\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#orderByDescending.__type-47\",\"classes\":\"\",\"parent\":\"Ix.Iterable.orderByDescending\"},{\"kind\":1024,\"name\":\"pairwise\",\"url\":\"classes/Ix.Iterable-1.html#pairwise\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#pairwise.__type-48\",\"classes\":\"\",\"parent\":\"Ix.Iterable.pairwise\"},{\"kind\":1024,\"name\":\"pluck\",\"url\":\"classes/Ix.Iterable-1.html#pluck\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#pluck.__type-49\",\"classes\":\"\",\"parent\":\"Ix.Iterable.pluck\"},{\"kind\":1024,\"name\":\"publish\",\"url\":\"classes/Ix.Iterable-1.html#publish\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#publish.__type-50\",\"classes\":\"\",\"parent\":\"Ix.Iterable.publish\"},{\"kind\":1024,\"name\":\"reduceRight\",\"url\":\"classes/Ix.Iterable-1.html#reduceRight\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#reduceRight.__type-55\",\"classes\":\"\",\"parent\":\"Ix.Iterable.reduceRight\"},{\"kind\":1024,\"name\":\"reduce\",\"url\":\"classes/Ix.Iterable-1.html#reduce\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#reduce.__type-53\",\"classes\":\"\",\"parent\":\"Ix.Iterable.reduce\"},{\"kind\":1024,\"name\":\"repeat\",\"url\":\"classes/Ix.Iterable-1.html#repeat\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#repeat.__type-57\",\"classes\":\"\",\"parent\":\"Ix.Iterable.repeat\"},{\"kind\":1024,\"name\":\"retry\",\"url\":\"classes/Ix.Iterable-1.html#retry\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#retry.__type-58\",\"classes\":\"\",\"parent\":\"Ix.Iterable.retry\"},{\"kind\":1024,\"name\":\"reverse\",\"url\":\"classes/Ix.Iterable-1.html#reverse\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#reverse.__type-59\",\"classes\":\"\",\"parent\":\"Ix.Iterable.reverse\"},{\"kind\":1024,\"name\":\"scanRight\",\"url\":\"classes/Ix.Iterable-1.html#scanRight\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#scanRight.__type-62\",\"classes\":\"\",\"parent\":\"Ix.Iterable.scanRight\"},{\"kind\":1024,\"name\":\"scan\",\"url\":\"classes/Ix.Iterable-1.html#scan\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#scan.__type-60\",\"classes\":\"\",\"parent\":\"Ix.Iterable.scan\"},{\"kind\":1024,\"name\":\"sequenceEqual\",\"url\":\"classes/Ix.Iterable-1.html#sequenceEqual\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#sequenceEqual.__type-64\",\"classes\":\"\",\"parent\":\"Ix.Iterable.sequenceEqual\"},{\"kind\":1024,\"name\":\"share\",\"url\":\"classes/Ix.Iterable-1.html#share\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#share.__type-65\",\"classes\":\"\",\"parent\":\"Ix.Iterable.share\"},{\"kind\":1024,\"name\":\"single\",\"url\":\"classes/Ix.Iterable-1.html#single\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#single.__type-68\",\"classes\":\"\",\"parent\":\"Ix.Iterable.single\"},{\"kind\":1024,\"name\":\"skipLast\",\"url\":\"classes/Ix.Iterable-1.html#skipLast\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#skipLast.__type-70\",\"classes\":\"\",\"parent\":\"Ix.Iterable.skipLast\"},{\"kind\":1024,\"name\":\"skip\",\"url\":\"classes/Ix.Iterable-1.html#skip\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#skip.__type-69\",\"classes\":\"\",\"parent\":\"Ix.Iterable.skip\"},{\"kind\":1024,\"name\":\"skipWhile\",\"url\":\"classes/Ix.Iterable-1.html#skipWhile\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#skipWhile.__type-71\",\"classes\":\"\",\"parent\":\"Ix.Iterable.skipWhile\"},{\"kind\":1024,\"name\":\"slice\",\"url\":\"classes/Ix.Iterable-1.html#slice\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#slice.__type-73\",\"classes\":\"\",\"parent\":\"Ix.Iterable.slice\"},{\"kind\":1024,\"name\":\"some\",\"url\":\"classes/Ix.Iterable-1.html#some\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#some.__type-74\",\"classes\":\"\",\"parent\":\"Ix.Iterable.some\"},{\"kind\":1024,\"name\":\"startWith\",\"url\":\"classes/Ix.Iterable-1.html#startWith\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#startWith.__type-75\",\"classes\":\"\",\"parent\":\"Ix.Iterable.startWith\"},{\"kind\":1024,\"name\":\"sum\",\"url\":\"classes/Ix.Iterable-1.html#sum\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#sum.__type-76\",\"classes\":\"\",\"parent\":\"Ix.Iterable.sum\"},{\"kind\":1024,\"name\":\"takeLast\",\"url\":\"classes/Ix.Iterable-1.html#takeLast\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#takeLast.__type-80\",\"classes\":\"\",\"parent\":\"Ix.Iterable.takeLast\"},{\"kind\":1024,\"name\":\"take\",\"url\":\"classes/Ix.Iterable-1.html#take\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#take.__type-79\",\"classes\":\"\",\"parent\":\"Ix.Iterable.take\"},{\"kind\":1024,\"name\":\"takeWhile\",\"url\":\"classes/Ix.Iterable-1.html#takeWhile\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#takeWhile.__type-81\",\"classes\":\"\",\"parent\":\"Ix.Iterable.takeWhile\"},{\"kind\":1024,\"name\":\"tap\",\"url\":\"classes/Ix.Iterable-1.html#tap\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#tap.__type-83\",\"classes\":\"\",\"parent\":\"Ix.Iterable.tap\"},{\"kind\":1024,\"name\":\"toArray\",\"url\":\"classes/Ix.Iterable-1.html#toArray\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#toArray.__type-85\",\"classes\":\"\",\"parent\":\"Ix.Iterable.toArray\"},{\"kind\":1024,\"name\":\"toMap\",\"url\":\"classes/Ix.Iterable-1.html#toMap\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#toMap.__type-89\",\"classes\":\"\",\"parent\":\"Ix.Iterable.toMap\"},{\"kind\":1024,\"name\":\"toSet\",\"url\":\"classes/Ix.Iterable-1.html#toSet\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#toSet.__type-94\",\"classes\":\"\",\"parent\":\"Ix.Iterable.toSet\"},{\"kind\":1024,\"name\":\"union\",\"url\":\"classes/Ix.Iterable-1.html#union\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#union.__type-95\",\"classes\":\"\",\"parent\":\"Ix.Iterable.union\"},{\"kind\":1024,\"name\":\"zip\",\"url\":\"classes/Ix.Iterable-1.html#zip\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.Iterable-1.html#zip.__type-96\",\"classes\":\"\",\"parent\":\"Ix.Iterable.zip\"},{\"kind\":2048,\"name\":\"[iterator]\",\"url\":\"classes/Ix.Iterable-1.html#_iterator_\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":4,\"name\":\"Iterable\",\"url\":\"modules/Ix.Iterable.html\",\"classes\":\"\",\"parent\":\"Ix\"},{\"kind\":64,\"name\":\"catchAll\",\"url\":\"functions/Ix.Iterable.catchAll.html\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":64,\"name\":\"catchError\",\"url\":\"functions/Ix.Iterable.catchError.html\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":64,\"name\":\"concat\",\"url\":\"functions/Ix.Iterable.concat.html\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":64,\"name\":\"create\",\"url\":\"functions/Ix.Iterable.create.html\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":64,\"name\":\"defer\",\"url\":\"functions/Ix.Iterable.defer.html\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":64,\"name\":\"empty\",\"url\":\"functions/Ix.Iterable.empty.html\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":64,\"name\":\"generate\",\"url\":\"functions/Ix.Iterable.generate.html\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":64,\"name\":\"iif\",\"url\":\"functions/Ix.Iterable.iif.html\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":64,\"name\":\"of\",\"url\":\"functions/Ix.Iterable.of.html\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":64,\"name\":\"onErrorResumeNext\",\"url\":\"functions/Ix.Iterable.onErrorResumeNext.html\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":64,\"name\":\"range\",\"url\":\"functions/Ix.Iterable.range.html\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":64,\"name\":\"repeatValue\",\"url\":\"functions/Ix.Iterable.repeatValue.html\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":64,\"name\":\"throwError\",\"url\":\"functions/Ix.Iterable.throwError.html\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":64,\"name\":\"whileDo\",\"url\":\"functions/Ix.Iterable.whileDo.html\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":64,\"name\":\"zip\",\"url\":\"functions/Ix.Iterable.zip.html\",\"classes\":\"\",\"parent\":\"Ix.Iterable\"},{\"kind\":128,\"name\":\"AsyncIterable\",\"url\":\"classes/Ix.AsyncIterable-1.html\",\"classes\":\"\",\"parent\":\"Ix\"},{\"kind\":2048,\"name\":\"from\",\"url\":\"classes/Ix.AsyncIterable-1.html#from\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":2048,\"name\":\"as\",\"url\":\"classes/Ix.AsyncIterable-1.html#as\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":512,\"name\":\"constructor\",\"url\":\"classes/Ix.AsyncIterable-1.html#constructor\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":2048,\"name\":\"forEach\",\"url\":\"classes/Ix.AsyncIterable-1.html#forEach\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":2048,\"name\":\"pipe\",\"url\":\"classes/Ix.AsyncIterable-1.html#pipe\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":1024,\"name\":\"toDOMStream\",\"url\":\"classes/Ix.AsyncIterable-1.html#toDOMStream\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#toDOMStream.__type-107\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.toDOMStream\"},{\"kind\":2048,\"name\":\"tee\",\"url\":\"classes/Ix.AsyncIterable-1.html#tee\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":2048,\"name\":\"pipeTo\",\"url\":\"classes/Ix.AsyncIterable-1.html#pipeTo\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":2048,\"name\":\"pipeThrough\",\"url\":\"classes/Ix.AsyncIterable-1.html#pipeThrough\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":1024,\"name\":\"toNodeStream\",\"url\":\"classes/Ix.AsyncIterable-1.html#toNodeStream\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#toNodeStream.__type-112\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.toNodeStream\"},{\"kind\":1024,\"name\":\"average\",\"url\":\"classes/Ix.AsyncIterable-1.html#average\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#average.__type\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.average\"},{\"kind\":1024,\"name\":\"batch\",\"url\":\"classes/Ix.AsyncIterable-1.html#batch\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#batch.__type-3\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.batch\"},{\"kind\":1024,\"name\":\"buffer\",\"url\":\"classes/Ix.AsyncIterable-1.html#buffer\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#buffer.__type-4\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.buffer\"},{\"kind\":1024,\"name\":\"catchError\",\"url\":\"classes/Ix.AsyncIterable-1.html#catchError\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#catchError.__type-5\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.catchError\"},{\"kind\":1024,\"name\":\"combineLatest\",\"url\":\"classes/Ix.AsyncIterable-1.html#combineLatest\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#combineLatest.__type-6\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.combineLatest\"},{\"kind\":1024,\"name\":\"concatAll\",\"url\":\"classes/Ix.AsyncIterable-1.html#concatAll\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#concatAll.__type-13\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.concatAll\"},{\"kind\":1024,\"name\":\"concatMap\",\"url\":\"classes/Ix.AsyncIterable-1.html#concatMap\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#concatMap.__type-14\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.concatMap\"},{\"kind\":1024,\"name\":\"concat\",\"url\":\"classes/Ix.AsyncIterable-1.html#concat\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#concat.__type-12\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.concat\"},{\"kind\":1024,\"name\":\"count\",\"url\":\"classes/Ix.AsyncIterable-1.html#count\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#count.__type-15\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.count\"},{\"kind\":1024,\"name\":\"debounce\",\"url\":\"classes/Ix.AsyncIterable-1.html#debounce\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#debounce.__type-16\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.debounce\"},{\"kind\":1024,\"name\":\"defaultIfEmpty\",\"url\":\"classes/Ix.AsyncIterable-1.html#defaultIfEmpty\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#defaultIfEmpty.__type-17\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.defaultIfEmpty\"},{\"kind\":1024,\"name\":\"delayEach\",\"url\":\"classes/Ix.AsyncIterable-1.html#delayEach\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#delayEach.__type-20\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.delayEach\"},{\"kind\":1024,\"name\":\"delay\",\"url\":\"classes/Ix.AsyncIterable-1.html#delay\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#delay.__type-18\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.delay\"},{\"kind\":1024,\"name\":\"distinct\",\"url\":\"classes/Ix.AsyncIterable-1.html#distinct\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#distinct.__type-22\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.distinct\"},{\"kind\":1024,\"name\":\"distinctUntilChanged\",\"url\":\"classes/Ix.AsyncIterable-1.html#distinctUntilChanged\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#distinctUntilChanged.__type-23\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.distinctUntilChanged\"},{\"kind\":1024,\"name\":\"doWhile\",\"url\":\"classes/Ix.AsyncIterable-1.html#doWhile\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#doWhile.__type-24\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.doWhile\"},{\"kind\":1024,\"name\":\"elementAt\",\"url\":\"classes/Ix.AsyncIterable-1.html#elementAt\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#elementAt.__type-25\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.elementAt\"},{\"kind\":1024,\"name\":\"endWith\",\"url\":\"classes/Ix.AsyncIterable-1.html#endWith\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#endWith.__type-26\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.endWith\"},{\"kind\":1024,\"name\":\"every\",\"url\":\"classes/Ix.AsyncIterable-1.html#every\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#every.__type-27\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.every\"},{\"kind\":1024,\"name\":\"except\",\"url\":\"classes/Ix.AsyncIterable-1.html#except\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#except.__type-28\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.except\"},{\"kind\":1024,\"name\":\"expand\",\"url\":\"classes/Ix.AsyncIterable-1.html#expand\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#expand.__type-29\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.expand\"},{\"kind\":1024,\"name\":\"filter\",\"url\":\"classes/Ix.AsyncIterable-1.html#filter\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#filter.__type-30\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.filter\"},{\"kind\":1024,\"name\":\"finalize\",\"url\":\"classes/Ix.AsyncIterable-1.html#finalize\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#finalize.__type-32\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.finalize\"},{\"kind\":1024,\"name\":\"findIndex\",\"url\":\"classes/Ix.AsyncIterable-1.html#findIndex\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#findIndex.__type-34\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.findIndex\"},{\"kind\":1024,\"name\":\"find\",\"url\":\"classes/Ix.AsyncIterable-1.html#find\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#find.__type-33\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.find\"},{\"kind\":1024,\"name\":\"first\",\"url\":\"classes/Ix.AsyncIterable-1.html#first\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#first.__type-35\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.first\"},{\"kind\":1024,\"name\":\"flatMap\",\"url\":\"classes/Ix.AsyncIterable-1.html#flatMap\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#flatMap.__type-37\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.flatMap\"},{\"kind\":1024,\"name\":\"flat\",\"url\":\"classes/Ix.AsyncIterable-1.html#flat\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#flat.__type-36\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.flat\"},{\"kind\":1024,\"name\":\"forkJoin\",\"url\":\"classes/Ix.AsyncIterable-1.html#forkJoin\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#forkJoin.__type-38\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.forkJoin\"},{\"kind\":1024,\"name\":\"groupBy\",\"url\":\"classes/Ix.AsyncIterable-1.html#groupBy\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#groupBy.__type-44\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.groupBy\"},{\"kind\":1024,\"name\":\"groupJoin\",\"url\":\"classes/Ix.AsyncIterable-1.html#groupJoin\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#groupJoin.__type-47\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.groupJoin\"},{\"kind\":1024,\"name\":\"ignoreElements\",\"url\":\"classes/Ix.AsyncIterable-1.html#ignoreElements\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#ignoreElements.__type-48\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.ignoreElements\"},{\"kind\":1024,\"name\":\"includes\",\"url\":\"classes/Ix.AsyncIterable-1.html#includes\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#includes.__type-49\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.includes\"},{\"kind\":1024,\"name\":\"innerJoin\",\"url\":\"classes/Ix.AsyncIterable-1.html#innerJoin\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#innerJoin.__type-50\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.innerJoin\"},{\"kind\":1024,\"name\":\"intersect\",\"url\":\"classes/Ix.AsyncIterable-1.html#intersect\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#intersect.__type-51\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.intersect\"},{\"kind\":1024,\"name\":\"isEmpty\",\"url\":\"classes/Ix.AsyncIterable-1.html#isEmpty\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#isEmpty.__type-52\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.isEmpty\"},{\"kind\":1024,\"name\":\"last\",\"url\":\"classes/Ix.AsyncIterable-1.html#last\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#last.__type-53\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.last\"},{\"kind\":1024,\"name\":\"map\",\"url\":\"classes/Ix.AsyncIterable-1.html#map\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#map.__type-54\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.map\"},{\"kind\":1024,\"name\":\"maxBy\",\"url\":\"classes/Ix.AsyncIterable-1.html#maxBy\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#maxBy.__type-57\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.maxBy\"},{\"kind\":1024,\"name\":\"max\",\"url\":\"classes/Ix.AsyncIterable-1.html#max\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#max.__type-55\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.max\"},{\"kind\":1024,\"name\":\"memoize\",\"url\":\"classes/Ix.AsyncIterable-1.html#memoize\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#memoize.__type-58\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.memoize\"},{\"kind\":1024,\"name\":\"mergeAll\",\"url\":\"classes/Ix.AsyncIterable-1.html#mergeAll\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#mergeAll.__type-62\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.mergeAll\"},{\"kind\":1024,\"name\":\"merge\",\"url\":\"classes/Ix.AsyncIterable-1.html#merge\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#merge.__type-61\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.merge\"},{\"kind\":1024,\"name\":\"minBy\",\"url\":\"classes/Ix.AsyncIterable-1.html#minBy\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#minBy.__type-65\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.minBy\"},{\"kind\":1024,\"name\":\"min\",\"url\":\"classes/Ix.AsyncIterable-1.html#min\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#min.__type-63\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.min\"},{\"kind\":1024,\"name\":\"onErrorResumeNext\",\"url\":\"classes/Ix.AsyncIterable-1.html#onErrorResumeNext\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#onErrorResumeNext.__type-66\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.onErrorResumeNext\"},{\"kind\":1024,\"name\":\"orderBy\",\"url\":\"classes/Ix.AsyncIterable-1.html#orderBy\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#orderBy.__type-67\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.orderBy\"},{\"kind\":1024,\"name\":\"orderByDescending\",\"url\":\"classes/Ix.AsyncIterable-1.html#orderByDescending\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#orderByDescending.__type-68\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.orderByDescending\"},{\"kind\":1024,\"name\":\"pairwise\",\"url\":\"classes/Ix.AsyncIterable-1.html#pairwise\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#pairwise.__type-69\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.pairwise\"},{\"kind\":1024,\"name\":\"pluck\",\"url\":\"classes/Ix.AsyncIterable-1.html#pluck\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#pluck.__type-70\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.pluck\"},{\"kind\":1024,\"name\":\"publish\",\"url\":\"classes/Ix.AsyncIterable-1.html#publish\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#publish.__type-71\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.publish\"},{\"kind\":1024,\"name\":\"switchAll\",\"url\":\"classes/Ix.AsyncIterable-1.html#switchAll\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#switchAll.__type-97\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.switchAll\"},{\"kind\":1024,\"name\":\"switchMap\",\"url\":\"classes/Ix.AsyncIterable-1.html#switchMap\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#switchMap.__type-98\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.switchMap\"},{\"kind\":1024,\"name\":\"reduceRight\",\"url\":\"classes/Ix.AsyncIterable-1.html#reduceRight\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#reduceRight.__type-75\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.reduceRight\"},{\"kind\":1024,\"name\":\"reduce\",\"url\":\"classes/Ix.AsyncIterable-1.html#reduce\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#reduce.__type-74\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.reduce\"},{\"kind\":1024,\"name\":\"repeat\",\"url\":\"classes/Ix.AsyncIterable-1.html#repeat\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#repeat.__type-76\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.repeat\"},{\"kind\":1024,\"name\":\"retry\",\"url\":\"classes/Ix.AsyncIterable-1.html#retry\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#retry.__type-77\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.retry\"},{\"kind\":1024,\"name\":\"reverse\",\"url\":\"classes/Ix.AsyncIterable-1.html#reverse\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#reverse.__type-78\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.reverse\"},{\"kind\":1024,\"name\":\"scanRight\",\"url\":\"classes/Ix.AsyncIterable-1.html#scanRight\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#scanRight.__type-80\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.scanRight\"},{\"kind\":1024,\"name\":\"scan\",\"url\":\"classes/Ix.AsyncIterable-1.html#scan\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#scan.__type-79\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.scan\"},{\"kind\":1024,\"name\":\"sequenceEqual\",\"url\":\"classes/Ix.AsyncIterable-1.html#sequenceEqual\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#sequenceEqual.__type-81\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.sequenceEqual\"},{\"kind\":1024,\"name\":\"share\",\"url\":\"classes/Ix.AsyncIterable-1.html#share\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#share.__type-82\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.share\"},{\"kind\":1024,\"name\":\"single\",\"url\":\"classes/Ix.AsyncIterable-1.html#single\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#single.__type-85\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.single\"},{\"kind\":1024,\"name\":\"skipLast\",\"url\":\"classes/Ix.AsyncIterable-1.html#skipLast\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#skipLast.__type-87\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.skipLast\"},{\"kind\":1024,\"name\":\"skip\",\"url\":\"classes/Ix.AsyncIterable-1.html#skip\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#skip.__type-86\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.skip\"},{\"kind\":1024,\"name\":\"skipUntil\",\"url\":\"classes/Ix.AsyncIterable-1.html#skipUntil\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#skipUntil.__type-88\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.skipUntil\"},{\"kind\":1024,\"name\":\"skipWhile\",\"url\":\"classes/Ix.AsyncIterable-1.html#skipWhile\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#skipWhile.__type-89\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.skipWhile\"},{\"kind\":1024,\"name\":\"slice\",\"url\":\"classes/Ix.AsyncIterable-1.html#slice\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#slice.__type-91\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.slice\"},{\"kind\":1024,\"name\":\"some\",\"url\":\"classes/Ix.AsyncIterable-1.html#some\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#some.__type-92\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.some\"},{\"kind\":1024,\"name\":\"startWith\",\"url\":\"classes/Ix.AsyncIterable-1.html#startWith\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#startWith.__type-93\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.startWith\"},{\"kind\":1024,\"name\":\"sum\",\"url\":\"classes/Ix.AsyncIterable-1.html#sum\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#sum.__type-94\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.sum\"},{\"kind\":1024,\"name\":\"takeLast\",\"url\":\"classes/Ix.AsyncIterable-1.html#takeLast\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#takeLast.__type-100\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.takeLast\"},{\"kind\":1024,\"name\":\"take\",\"url\":\"classes/Ix.AsyncIterable-1.html#take\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#take.__type-99\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.take\"},{\"kind\":1024,\"name\":\"takeUntil\",\"url\":\"classes/Ix.AsyncIterable-1.html#takeUntil\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#takeUntil.__type-101\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.takeUntil\"},{\"kind\":1024,\"name\":\"takeWhile\",\"url\":\"classes/Ix.AsyncIterable-1.html#takeWhile\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#takeWhile.__type-102\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.takeWhile\"},{\"kind\":1024,\"name\":\"tap\",\"url\":\"classes/Ix.AsyncIterable-1.html#tap\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#tap.__type-104\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.tap\"},{\"kind\":1024,\"name\":\"throttle\",\"url\":\"classes/Ix.AsyncIterable-1.html#throttle\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#throttle.__type-105\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.throttle\"},{\"kind\":1024,\"name\":\"toArray\",\"url\":\"classes/Ix.AsyncIterable-1.html#toArray\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#toArray.__type-106\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.toArray\"},{\"kind\":1024,\"name\":\"toMap\",\"url\":\"classes/Ix.AsyncIterable-1.html#toMap\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#toMap.__type-110\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.toMap\"},{\"kind\":1024,\"name\":\"toObservable\",\"url\":\"classes/Ix.AsyncIterable-1.html#toObservable\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#toObservable.__type-115\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.toObservable\"},{\"kind\":1024,\"name\":\"toSet\",\"url\":\"classes/Ix.AsyncIterable-1.html#toSet\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#toSet.__type-116\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.toSet\"},{\"kind\":1024,\"name\":\"union\",\"url\":\"classes/Ix.AsyncIterable-1.html#union\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#union.__type-117\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.union\"},{\"kind\":1024,\"name\":\"withLatestFrom\",\"url\":\"classes/Ix.AsyncIterable-1.html#withLatestFrom\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#withLatestFrom.__type-118\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.withLatestFrom\"},{\"kind\":1024,\"name\":\"zip\",\"url\":\"classes/Ix.AsyncIterable-1.html#zip\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"classes/Ix.AsyncIterable-1.html#zip.__type-124\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.zip\"},{\"kind\":2048,\"name\":\"[asyncIterator]\",\"url\":\"classes/Ix.AsyncIterable-1.html#_asyncIterator_\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":4,\"name\":\"AsyncIterable\",\"url\":\"modules/Ix.AsyncIterable.html\",\"classes\":\"\",\"parent\":\"Ix\"},{\"kind\":64,\"name\":\"asyncifyErrback\",\"url\":\"functions/Ix.AsyncIterable.asyncifyErrback.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"functions/Ix.AsyncIterable.asyncifyErrback.html#asyncifyErrback.__type\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.asyncifyErrback.asyncifyErrback\"},{\"kind\":64,\"name\":\"asyncify\",\"url\":\"functions/Ix.AsyncIterable.asyncify.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"functions/Ix.AsyncIterable.asyncify.html#asyncify.__type\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable.asyncify.asyncify\"},{\"kind\":64,\"name\":\"catchAll\",\"url\":\"functions/Ix.AsyncIterable.catchAll.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"catchError\",\"url\":\"functions/Ix.AsyncIterable.catchError.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"combineLatest\",\"url\":\"functions/Ix.AsyncIterable.combineLatest.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"concat\",\"url\":\"functions/Ix.AsyncIterable.concat.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"create\",\"url\":\"functions/Ix.AsyncIterable.create.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"defer\",\"url\":\"functions/Ix.AsyncIterable.defer.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"empty\",\"url\":\"functions/Ix.AsyncIterable.empty.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"forkJoin\",\"url\":\"functions/Ix.AsyncIterable.forkJoin.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"fromDOMStream\",\"url\":\"functions/Ix.AsyncIterable.fromDOMStream.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"fromEventPattern\",\"url\":\"functions/Ix.AsyncIterable.fromEventPattern.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"fromEvent\",\"url\":\"functions/Ix.AsyncIterable.fromEvent.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"fromNodeStream\",\"url\":\"functions/Ix.AsyncIterable.fromNodeStream.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"generateTime\",\"url\":\"functions/Ix.AsyncIterable.generateTime.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"generate\",\"url\":\"functions/Ix.AsyncIterable.generate.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"iif\",\"url\":\"functions/Ix.AsyncIterable.iif.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"merge\",\"url\":\"functions/Ix.AsyncIterable.merge.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"never\",\"url\":\"functions/Ix.AsyncIterable.never.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"of\",\"url\":\"functions/Ix.AsyncIterable.of.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"onErrorResumeNext\",\"url\":\"functions/Ix.AsyncIterable.onErrorResumeNext.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"race\",\"url\":\"functions/Ix.AsyncIterable.race.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"range\",\"url\":\"functions/Ix.AsyncIterable.range.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"repeatValue\",\"url\":\"functions/Ix.AsyncIterable.repeatValue.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"throwError\",\"url\":\"functions/Ix.AsyncIterable.throwError.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"whileDo\",\"url\":\"functions/Ix.AsyncIterable.whileDo.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"zip\",\"url\":\"functions/Ix.AsyncIterable.zip.html\",\"classes\":\"\",\"parent\":\"Ix.AsyncIterable\"},{\"kind\":64,\"name\":\"fromDOMStream\",\"url\":\"functions/dom.fromDOMStream.html\",\"classes\":\"\",\"parent\":\"dom\"},{\"kind\":8388608,\"name\":\"Iterable\",\"url\":\"modules/dom.html#Iterable\",\"classes\":\"\",\"parent\":\"dom\"},{\"kind\":8388608,\"name\":\"AsyncIterable\",\"url\":\"modules/dom.html#AsyncIterable\",\"classes\":\"\",\"parent\":\"dom\"},{\"kind\":64,\"name\":\"fromNodeStream\",\"url\":\"functions/node.fromNodeStream.html\",\"classes\":\"\",\"parent\":\"node\"},{\"kind\":8388608,\"name\":\"Iterable\",\"url\":\"modules/node.html#Iterable\",\"classes\":\"\",\"parent\":\"node\"},{\"kind\":8388608,\"name\":\"AsyncIterable\",\"url\":\"modules/node.html#AsyncIterable\",\"classes\":\"\",\"parent\":\"node\"},{\"kind\":64,\"name\":\"average\",\"url\":\"functions/iterable.average.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":8388608,\"name\":\"catchAll\",\"url\":\"modules/iterable.html#catchAll\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":8388608,\"name\":\"catchError\",\"url\":\"modules/iterable.html#catchError\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"concat\",\"url\":\"functions/iterable.concat.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"count\",\"url\":\"functions/iterable.count.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"create\",\"url\":\"functions/iterable.create.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"defer\",\"url\":\"functions/iterable.defer.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"elementAt\",\"url\":\"functions/iterable.elementAt.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"empty\",\"url\":\"functions/iterable.empty.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"every\",\"url\":\"functions/iterable.every.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"findIndex\",\"url\":\"functions/iterable.findIndex.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"find\",\"url\":\"functions/iterable.find.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"first\",\"url\":\"functions/iterable.first.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"generate\",\"url\":\"functions/iterable.generate.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":8388608,\"name\":\"iif\",\"url\":\"modules/iterable.html#iif\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"includes\",\"url\":\"functions/iterable.includes.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"isEmpty\",\"url\":\"functions/iterable.isEmpty.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":8388608,\"name\":\"IterableX\",\"url\":\"modules/iterable.html#IterableX\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"as\",\"url\":\"functions/iterable.as.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"from\",\"url\":\"functions/iterable.from.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"last\",\"url\":\"functions/iterable.last.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"max\",\"url\":\"functions/iterable.max.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"maxBy\",\"url\":\"functions/iterable.maxBy.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"min\",\"url\":\"functions/iterable.min.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"minBy\",\"url\":\"functions/iterable.minBy.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":8388608,\"name\":\"of\",\"url\":\"modules/iterable.html#of\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"onErrorResumeNext\",\"url\":\"functions/iterable.onErrorResumeNext.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"range\",\"url\":\"functions/iterable.range.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"reduceRight\",\"url\":\"functions/iterable.reduceRight.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"reduce\",\"url\":\"functions/iterable.reduce.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"repeatValue\",\"url\":\"functions/iterable.repeatValue.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"sequenceEqual\",\"url\":\"functions/iterable.sequenceEqual.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"single\",\"url\":\"functions/iterable.single.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"some\",\"url\":\"functions/iterable.some.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"sum\",\"url\":\"functions/iterable.sum.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":8388608,\"name\":\"throwError\",\"url\":\"modules/iterable.html#throwError\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"toArray\",\"url\":\"functions/iterable.toArray.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"toDOMStream\",\"url\":\"functions/iterable.toDOMStream.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"toMap\",\"url\":\"functions/iterable.toMap.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"toSet\",\"url\":\"functions/iterable.toSet.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":8388608,\"name\":\"whileDo\",\"url\":\"modules/iterable.html#whileDo\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"zip\",\"url\":\"functions/iterable.zip.html\",\"classes\":\"\",\"parent\":\"iterable\"},{\"kind\":64,\"name\":\"buffer\",\"url\":\"functions/iterable_operators.buffer.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"catchError\",\"url\":\"functions/iterable_operators.catchError.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"concatAll\",\"url\":\"functions/iterable_operators.concatAll.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"concatWith\",\"url\":\"functions/iterable_operators.concatWith.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"defaultIfEmpty\",\"url\":\"functions/iterable_operators.defaultIfEmpty.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"distinct\",\"url\":\"functions/iterable_operators.distinct.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"distinctUntilChanged\",\"url\":\"functions/iterable_operators.distinctUntilChanged.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"doWhile\",\"url\":\"functions/iterable_operators.doWhile.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"endWith\",\"url\":\"functions/iterable_operators.endWith.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"except\",\"url\":\"functions/iterable_operators.except.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"expand\",\"url\":\"functions/iterable_operators.expand.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"filter\",\"url\":\"functions/iterable_operators.filter.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"finalize\",\"url\":\"functions/iterable_operators.finalize.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"flatMap\",\"url\":\"functions/iterable_operators.flatMap.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"flat\",\"url\":\"functions/iterable_operators.flat.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"groupBy\",\"url\":\"functions/iterable_operators.groupBy.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"groupJoin\",\"url\":\"functions/iterable_operators.groupJoin.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"ignoreElements\",\"url\":\"functions/iterable_operators.ignoreElements.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"innerJoin\",\"url\":\"functions/iterable_operators.innerJoin.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"intersect\",\"url\":\"functions/iterable_operators.intersect.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"map\",\"url\":\"functions/iterable_operators.map.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"memoize\",\"url\":\"functions/iterable_operators.memoize.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"orderBy\",\"url\":\"functions/iterable_operators.orderBy.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"orderByDescending\",\"url\":\"functions/iterable_operators.orderByDescending.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"thenBy\",\"url\":\"functions/iterable_operators.thenBy.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"thenByDescending\",\"url\":\"functions/iterable_operators.thenByDescending.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"pairwise\",\"url\":\"functions/iterable_operators.pairwise.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"pluck\",\"url\":\"functions/iterable_operators.pluck.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"publish\",\"url\":\"functions/iterable_operators.publish.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"repeat\",\"url\":\"functions/iterable_operators.repeat.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"retry\",\"url\":\"functions/iterable_operators.retry.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"reverse\",\"url\":\"functions/iterable_operators.reverse.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"scanRight\",\"url\":\"functions/iterable_operators.scanRight.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"scan\",\"url\":\"functions/iterable_operators.scan.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"share\",\"url\":\"functions/iterable_operators.share.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"skipLast\",\"url\":\"functions/iterable_operators.skipLast.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"skip\",\"url\":\"functions/iterable_operators.skip.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"skipWhile\",\"url\":\"functions/iterable_operators.skipWhile.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"slice\",\"url\":\"functions/iterable_operators.slice.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"startWith\",\"url\":\"functions/iterable_operators.startWith.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"takeLast\",\"url\":\"functions/iterable_operators.takeLast.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"take\",\"url\":\"functions/iterable_operators.take.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"takeWhile\",\"url\":\"functions/iterable_operators.takeWhile.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"tap\",\"url\":\"functions/iterable_operators.tap.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"toDOMStream\",\"url\":\"functions/iterable_operators.toDOMStream.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"union\",\"url\":\"functions/iterable_operators.union.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"zipWith\",\"url\":\"functions/iterable_operators.zipWith.html\",\"classes\":\"\",\"parent\":\"iterable/operators\"},{\"kind\":64,\"name\":\"asyncifyErrback\",\"url\":\"functions/asynciterable.asyncifyErrback.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"functions/asynciterable.asyncifyErrback.html#asyncifyErrback.__type\",\"classes\":\"\",\"parent\":\"asynciterable.asyncifyErrback.asyncifyErrback\"},{\"kind\":64,\"name\":\"asyncify\",\"url\":\"functions/asynciterable.asyncify.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"functions/asynciterable.asyncify.html#asyncify.__type\",\"classes\":\"\",\"parent\":\"asynciterable.asyncify.asyncify\"},{\"kind\":8388608,\"name\":\"AsyncIterableX\",\"url\":\"modules/asynciterable.html#AsyncIterableX\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"as\",\"url\":\"functions/asynciterable.as.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"from\",\"url\":\"functions/asynciterable.from.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"average\",\"url\":\"functions/asynciterable.average.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":8388608,\"name\":\"catchAll\",\"url\":\"modules/asynciterable.html#catchAll\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":8388608,\"name\":\"catchError\",\"url\":\"modules/asynciterable.html#catchError\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"combineLatest\",\"url\":\"functions/asynciterable.combineLatest.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"concat\",\"url\":\"functions/asynciterable.concat.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"_concatAll\",\"url\":\"functions/asynciterable._concatAll.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"count\",\"url\":\"functions/asynciterable.count.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"create\",\"url\":\"functions/asynciterable.create.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"defer\",\"url\":\"functions/asynciterable.defer.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"elementAt\",\"url\":\"functions/asynciterable.elementAt.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"empty\",\"url\":\"functions/asynciterable.empty.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"every\",\"url\":\"functions/asynciterable.every.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"findIndex\",\"url\":\"functions/asynciterable.findIndex.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"find\",\"url\":\"functions/asynciterable.find.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"first\",\"url\":\"functions/asynciterable.first.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"forkJoin\",\"url\":\"functions/asynciterable.forkJoin.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":8388608,\"name\":\"fromDOMStream\",\"url\":\"modules/asynciterable.html#fromDOMStream\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"fromEventPattern\",\"url\":\"functions/asynciterable.fromEventPattern.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"fromEvent\",\"url\":\"functions/asynciterable.fromEvent.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"generate\",\"url\":\"functions/asynciterable.generate.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"generateTime\",\"url\":\"functions/asynciterable.generateTime.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":8388608,\"name\":\"iif\",\"url\":\"modules/asynciterable.html#iif\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"includes\",\"url\":\"functions/asynciterable.includes.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"interval\",\"url\":\"functions/asynciterable.interval.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"isEmpty\",\"url\":\"functions/asynciterable.isEmpty.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"last\",\"url\":\"functions/asynciterable.last.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"max\",\"url\":\"functions/asynciterable.max.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"maxBy\",\"url\":\"functions/asynciterable.maxBy.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"merge\",\"url\":\"functions/asynciterable.merge.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"min\",\"url\":\"functions/asynciterable.min.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"minBy\",\"url\":\"functions/asynciterable.minBy.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"never\",\"url\":\"functions/asynciterable.never.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":8388608,\"name\":\"of\",\"url\":\"modules/asynciterable.html#of\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"onErrorResumeNext\",\"url\":\"functions/asynciterable.onErrorResumeNext.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"race\",\"url\":\"functions/asynciterable.race.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"range\",\"url\":\"functions/asynciterable.range.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"reduceRight\",\"url\":\"functions/asynciterable.reduceRight.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"reduce\",\"url\":\"functions/asynciterable.reduce.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"repeatValue\",\"url\":\"functions/asynciterable.repeatValue.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"sequenceEqual\",\"url\":\"functions/asynciterable.sequenceEqual.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"single\",\"url\":\"functions/asynciterable.single.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"some\",\"url\":\"functions/asynciterable.some.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"sum\",\"url\":\"functions/asynciterable.sum.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":8388608,\"name\":\"throwError\",\"url\":\"modules/asynciterable.html#throwError\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"toArray\",\"url\":\"functions/asynciterable.toArray.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"toDOMStream\",\"url\":\"functions/asynciterable.toDOMStream.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"toMap\",\"url\":\"functions/asynciterable.toMap.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"toObservable\",\"url\":\"functions/asynciterable.toObservable.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"toSet\",\"url\":\"functions/asynciterable.toSet.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":8388608,\"name\":\"whileDo\",\"url\":\"modules/asynciterable.html#whileDo\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"zip\",\"url\":\"functions/asynciterable.zip.html\",\"classes\":\"\",\"parent\":\"asynciterable\"},{\"kind\":64,\"name\":\"batch\",\"url\":\"functions/asynciterable_operators.batch.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"buffer\",\"url\":\"functions/asynciterable_operators.buffer.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"bufferCountOrTime\",\"url\":\"functions/asynciterable_operators.bufferCountOrTime.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"catchError\",\"url\":\"functions/asynciterable_operators.catchError.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"combineLatestWith\",\"url\":\"functions/asynciterable_operators.combineLatestWith.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"concatAll\",\"url\":\"functions/asynciterable_operators.concatAll.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"concatMap\",\"url\":\"functions/asynciterable_operators.concatMap.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"concatWith\",\"url\":\"functions/asynciterable_operators.concatWith.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"debounce\",\"url\":\"functions/asynciterable_operators.debounce.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"defaultIfEmpty\",\"url\":\"functions/asynciterable_operators.defaultIfEmpty.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"delayEach\",\"url\":\"functions/asynciterable_operators.delayEach.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"delay\",\"url\":\"functions/asynciterable_operators.delay.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"distinct\",\"url\":\"functions/asynciterable_operators.distinct.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"distinctUntilChanged\",\"url\":\"functions/asynciterable_operators.distinctUntilChanged.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"doWhile\",\"url\":\"functions/asynciterable_operators.doWhile.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"endWith\",\"url\":\"functions/asynciterable_operators.endWith.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"except\",\"url\":\"functions/asynciterable_operators.except.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"expand\",\"url\":\"functions/asynciterable_operators.expand.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"filter\",\"url\":\"functions/asynciterable_operators.filter.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"finalize\",\"url\":\"functions/asynciterable_operators.finalize.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"flatMap\",\"url\":\"functions/asynciterable_operators.flatMap.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"flat\",\"url\":\"functions/asynciterable_operators.flat.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"functions/asynciterable_operators.flat.html#flat.__type\",\"classes\":\"\",\"parent\":\"asynciterable/operators.flat.flat\"},{\"kind\":64,\"name\":\"groupBy\",\"url\":\"functions/asynciterable_operators.groupBy.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"groupJoin\",\"url\":\"functions/asynciterable_operators.groupJoin.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"ignoreElements\",\"url\":\"functions/asynciterable_operators.ignoreElements.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"innerJoin\",\"url\":\"functions/asynciterable_operators.innerJoin.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"intersect\",\"url\":\"functions/asynciterable_operators.intersect.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"map\",\"url\":\"functions/asynciterable_operators.map.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"memoize\",\"url\":\"functions/asynciterable_operators.memoize.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"mergeAll\",\"url\":\"functions/asynciterable_operators.mergeAll.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"functions/asynciterable_operators.mergeAll.html#mergeAll.__type\",\"classes\":\"\",\"parent\":\"asynciterable/operators.mergeAll.mergeAll\"},{\"kind\":64,\"name\":\"mergeWith\",\"url\":\"functions/asynciterable_operators.mergeWith.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"orderBy\",\"url\":\"functions/asynciterable_operators.orderBy.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"orderByDescending\",\"url\":\"functions/asynciterable_operators.orderByDescending.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"thenBy\",\"url\":\"functions/asynciterable_operators.thenBy.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"thenByDescending\",\"url\":\"functions/asynciterable_operators.thenByDescending.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"pairwise\",\"url\":\"functions/asynciterable_operators.pairwise.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"pluck\",\"url\":\"functions/asynciterable_operators.pluck.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"publish\",\"url\":\"functions/asynciterable_operators.publish.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"raceWith\",\"url\":\"functions/asynciterable_operators.raceWith.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"repeat\",\"url\":\"functions/asynciterable_operators.repeat.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"retry\",\"url\":\"functions/asynciterable_operators.retry.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"reverse\",\"url\":\"functions/asynciterable_operators.reverse.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"scanRight\",\"url\":\"functions/asynciterable_operators.scanRight.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"scan\",\"url\":\"functions/asynciterable_operators.scan.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"share\",\"url\":\"functions/asynciterable_operators.share.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"skipLast\",\"url\":\"functions/asynciterable_operators.skipLast.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"skip\",\"url\":\"functions/asynciterable_operators.skip.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"skipUntil\",\"url\":\"functions/asynciterable_operators.skipUntil.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"skipWhile\",\"url\":\"functions/asynciterable_operators.skipWhile.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"slice\",\"url\":\"functions/asynciterable_operators.slice.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"startWith\",\"url\":\"functions/asynciterable_operators.startWith.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"functions/asynciterable_operators.startWith.html#startWith.__type\",\"classes\":\"\",\"parent\":\"asynciterable/operators.startWith.startWith\"},{\"kind\":64,\"name\":\"switchAll\",\"url\":\"functions/asynciterable_operators.switchAll.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":65536,\"name\":\"__type\",\"url\":\"functions/asynciterable_operators.switchAll.html#switchAll.__type\",\"classes\":\"\",\"parent\":\"asynciterable/operators.switchAll.switchAll\"},{\"kind\":64,\"name\":\"switchMap\",\"url\":\"functions/asynciterable_operators.switchMap.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"takeLast\",\"url\":\"functions/asynciterable_operators.takeLast.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"take\",\"url\":\"functions/asynciterable_operators.take.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"takeUntil\",\"url\":\"functions/asynciterable_operators.takeUntil.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"takeWhile\",\"url\":\"functions/asynciterable_operators.takeWhile.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"tap\",\"url\":\"functions/asynciterable_operators.tap.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"throttle\",\"url\":\"functions/asynciterable_operators.throttle.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"timeInterval\",\"url\":\"functions/asynciterable_operators.timeInterval.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"timeout\",\"url\":\"functions/asynciterable_operators.timeout.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"timestamp\",\"url\":\"functions/asynciterable_operators.timestamp.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"toDOMStream\",\"url\":\"functions/asynciterable_operators.toDOMStream.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"union\",\"url\":\"functions/asynciterable_operators.union.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"withAbort\",\"url\":\"functions/asynciterable_operators.withAbort.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"wrapWithAbort\",\"url\":\"functions/asynciterable_operators.wrapWithAbort.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"withLatestFrom\",\"url\":\"functions/asynciterable_operators.withLatestFrom.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"},{\"kind\":64,\"name\":\"zipWith\",\"url\":\"functions/asynciterable_operators.zipWith.html\",\"classes\":\"\",\"parent\":\"asynciterable/operators\"}],\"index\":{\"version\":\"2.3.9\",\"fields\":[\"name\",\"comment\"],\"fieldVectors\":[[\"name/0\",[0,60.096]],[\"comment/0\",[]],[\"name/1\",[1,60.096]],[\"comment/1\",[]],[\"name/2\",[2,60.096]],[\"comment/2\",[]],[\"name/3\",[3,47.103]],[\"comment/3\",[]],[\"name/4\",[4,60.096]],[\"comment/4\",[]],[\"name/5\",[5,47.103]],[\"comment/5\",[]],[\"name/6\",[6,60.096]],[\"comment/6\",[]],[\"name/7\",[3,47.103]],[\"comment/7\",[]],[\"name/8\",[7,49.11]],[\"comment/8\",[]],[\"name/9\",[8,49.11]],[\"comment/9\",[]],[\"name/10\",[9,54.988]],[\"comment/10\",[]],[\"name/11\",[10,54.988]],[\"comment/11\",[]],[\"name/12\",[11,54.988]],[\"comment/12\",[]],[\"name/13\",[12,45.433]],[\"comment/13\",[]],[\"name/14\",[13,13.122]],[\"comment/14\",[]],[\"name/15\",[14,54.988]],[\"comment/15\",[]],[\"name/16\",[15,54.988]],[\"comment/16\",[]],[\"name/17\",[16,54.988]],[\"comment/17\",[]],[\"name/18\",[17,54.988]],[\"comment/18\",[]],[\"name/19\",[13,13.122]],[\"comment/19\",[]],[\"name/20\",[18,49.11]],[\"comment/20\",[]],[\"name/21\",[13,13.122]],[\"comment/21\",[]],[\"name/22\",[19,49.11]],[\"comment/22\",[]],[\"name/23\",[13,13.122]],[\"comment/23\",[]],[\"name/24\",[20,42.75]],[\"comment/24\",[]],[\"name/25\",[13,13.122]],[\"comment/25\",[]],[\"name/26\",[21,49.11]],[\"comment/26\",[]],[\"name/27\",[13,13.122]],[\"comment/27\",[]],[\"name/28\",[22,45.433]],[\"comment/28\",[]],[\"name/29\",[13,13.122]],[\"comment/29\",[]],[\"name/30\",[23,49.11]],[\"comment/30\",[]],[\"name/31\",[13,13.122]],[\"comment/31\",[]],[\"name/32\",[24,49.11]],[\"comment/32\",[]],[\"name/33\",[13,13.122]],[\"comment/33\",[]],[\"name/34\",[25,49.11]],[\"comment/34\",[]],[\"name/35\",[13,13.122]],[\"comment/35\",[]],[\"name/36\",[26,49.11]],[\"comment/36\",[]],[\"name/37\",[13,13.122]],[\"comment/37\",[]],[\"name/38\",[27,49.11]],[\"comment/38\",[]],[\"name/39\",[13,13.122]],[\"comment/39\",[]],[\"name/40\",[28,49.11]],[\"comment/40\",[]],[\"name/41\",[13,13.122]],[\"comment/41\",[]],[\"name/42\",[29,49.11]],[\"comment/42\",[]],[\"name/43\",[13,13.122]],[\"comment/43\",[]],[\"name/44\",[30,49.11]],[\"comment/44\",[]],[\"name/45\",[13,13.122]],[\"comment/45\",[]],[\"name/46\",[31,49.11]],[\"comment/46\",[]],[\"name/47\",[13,13.122]],[\"comment/47\",[]],[\"name/48\",[32,49.11]],[\"comment/48\",[]],[\"name/49\",[13,13.122]],[\"comment/49\",[]],[\"name/50\",[33,49.11]],[\"comment/50\",[]],[\"name/51\",[13,13.122]],[\"comment/51\",[]],[\"name/52\",[34,60.096]],[\"comment/52\",[]],[\"name/53\",[13,13.122]],[\"comment/53\",[]],[\"name/54\",[35,49.11]],[\"comment/54\",[]],[\"name/55\",[13,13.122]],[\"comment/55\",[]],[\"name/56\",[36,49.11]],[\"comment/56\",[]],[\"name/57\",[13,13.122]],[\"comment/57\",[]],[\"name/58\",[37,49.11]],[\"comment/58\",[]],[\"name/59\",[13,13.122]],[\"comment/59\",[]],[\"name/60\",[38,49.11]],[\"comment/60\",[]],[\"name/61\",[13,13.122]],[\"comment/61\",[]],[\"name/62\",[39,49.11]],[\"comment/62\",[]],[\"name/63\",[13,13.122]],[\"comment/63\",[]],[\"name/64\",[40,49.11]],[\"comment/64\",[]],[\"name/65\",[13,13.122]],[\"comment/65\",[]],[\"name/66\",[41,49.11]],[\"comment/66\",[]],[\"name/67\",[13,13.122]],[\"comment/67\",[]],[\"name/68\",[42,49.11]],[\"comment/68\",[]],[\"name/69\",[13,13.122]],[\"comment/69\",[]],[\"name/70\",[43,49.11]],[\"comment/70\",[]],[\"name/71\",[13,13.122]],[\"comment/71\",[]],[\"name/72\",[44,49.11]],[\"comment/72\",[]],[\"name/73\",[13,13.122]],[\"comment/73\",[]],[\"name/74\",[45,49.11]],[\"comment/74\",[]],[\"name/75\",[13,13.122]],[\"comment/75\",[]],[\"name/76\",[46,49.11]],[\"comment/76\",[]],[\"name/77\",[13,13.122]],[\"comment/77\",[]],[\"name/78\",[47,49.11]],[\"comment/78\",[]],[\"name/79\",[13,13.122]],[\"comment/79\",[]],[\"name/80\",[48,49.11]],[\"comment/80\",[]],[\"name/81\",[13,13.122]],[\"comment/81\",[]],[\"name/82\",[49,49.11]],[\"comment/82\",[]],[\"name/83\",[13,13.122]],[\"comment/83\",[]],[\"name/84\",[50,49.11]],[\"comment/84\",[]],[\"name/85\",[13,13.122]],[\"comment/85\",[]],[\"name/86\",[51,49.11]],[\"comment/86\",[]],[\"name/87\",[13,13.122]],[\"comment/87\",[]],[\"name/88\",[52,49.11]],[\"comment/88\",[]],[\"name/89\",[13,13.122]],[\"comment/89\",[]],[\"name/90\",[53,49.11]],[\"comment/90\",[]],[\"name/91\",[13,13.122]],[\"comment/91\",[]],[\"name/92\",[54,45.433]],[\"comment/92\",[]],[\"name/93\",[13,13.122]],[\"comment/93\",[]],[\"name/94\",[55,49.11]],[\"comment/94\",[]],[\"name/95\",[13,13.122]],[\"comment/95\",[]],[\"name/96\",[56,49.11]],[\"comment/96\",[]],[\"name/97\",[13,13.122]],[\"comment/97\",[]],[\"name/98\",[57,49.11]],[\"comment/98\",[]],[\"name/99\",[13,13.122]],[\"comment/99\",[]],[\"name/100\",[58,49.11]],[\"comment/100\",[]],[\"name/101\",[13,13.122]],[\"comment/101\",[]],[\"name/102\",[59,49.11]],[\"comment/102\",[]],[\"name/103\",[13,13.122]],[\"comment/103\",[]],[\"name/104\",[60,49.11]],[\"comment/104\",[]],[\"name/105\",[13,13.122]],[\"comment/105\",[]],[\"name/106\",[61,49.11]],[\"comment/106\",[]],[\"name/107\",[13,13.122]],[\"comment/107\",[]],[\"name/108\",[62,49.11]],[\"comment/108\",[]],[\"name/109\",[13,13.122]],[\"comment/109\",[]],[\"name/110\",[63,49.11]],[\"comment/110\",[]],[\"name/111\",[13,13.122]],[\"comment/111\",[]],[\"name/112\",[64,49.11]],[\"comment/112\",[]],[\"name/113\",[13,13.122]],[\"comment/113\",[]],[\"name/114\",[65,49.11]],[\"comment/114\",[]],[\"name/115\",[13,13.122]],[\"comment/115\",[]],[\"name/116\",[66,49.11]],[\"comment/116\",[]],[\"name/117\",[13,13.122]],[\"comment/117\",[]],[\"name/118\",[67,49.11]],[\"comment/118\",[]],[\"name/119\",[13,13.122]],[\"comment/119\",[]],[\"name/120\",[68,49.11]],[\"comment/120\",[]],[\"name/121\",[13,13.122]],[\"comment/121\",[]],[\"name/122\",[69,49.11]],[\"comment/122\",[]],[\"name/123\",[13,13.122]],[\"comment/123\",[]],[\"name/124\",[70,49.11]],[\"comment/124\",[]],[\"name/125\",[13,13.122]],[\"comment/125\",[]],[\"name/126\",[71,49.11]],[\"comment/126\",[]],[\"name/127\",[13,13.122]],[\"comment/127\",[]],[\"name/128\",[72,49.11]],[\"comment/128\",[]],[\"name/129\",[13,13.122]],[\"comment/129\",[]],[\"name/130\",[73,49.11]],[\"comment/130\",[]],[\"name/131\",[13,13.122]],[\"comment/131\",[]],[\"name/132\",[74,49.11]],[\"comment/132\",[]],[\"name/133\",[13,13.122]],[\"comment/133\",[]],[\"name/134\",[75,49.11]],[\"comment/134\",[]],[\"name/135\",[13,13.122]],[\"comment/135\",[]],[\"name/136\",[76,49.11]],[\"comment/136\",[]],[\"name/137\",[13,13.122]],[\"comment/137\",[]],[\"name/138\",[77,49.11]],[\"comment/138\",[]],[\"name/139\",[13,13.122]],[\"comment/139\",[]],[\"name/140\",[78,49.11]],[\"comment/140\",[]],[\"name/141\",[13,13.122]],[\"comment/141\",[]],[\"name/142\",[79,49.11]],[\"comment/142\",[]],[\"name/143\",[13,13.122]],[\"comment/143\",[]],[\"name/144\",[80,49.11]],[\"comment/144\",[]],[\"name/145\",[13,13.122]],[\"comment/145\",[]],[\"name/146\",[81,49.11]],[\"comment/146\",[]],[\"name/147\",[13,13.122]],[\"comment/147\",[]],[\"name/148\",[82,49.11]],[\"comment/148\",[]],[\"name/149\",[13,13.122]],[\"comment/149\",[]],[\"name/150\",[83,49.11]],[\"comment/150\",[]],[\"name/151\",[13,13.122]],[\"comment/151\",[]],[\"name/152\",[84,49.11]],[\"comment/152\",[]],[\"name/153\",[13,13.122]],[\"comment/153\",[]],[\"name/154\",[85,45.433]],[\"comment/154\",[]],[\"name/155\",[13,13.122]],[\"comment/155\",[]],[\"name/156\",[86,60.096]],[\"comment/156\",[]],[\"name/157\",[3,47.103]],[\"comment/157\",[]],[\"name/158\",[87,49.11]],[\"comment/158\",[]],[\"name/159\",[20,42.75]],[\"comment/159\",[]],[\"name/160\",[22,45.433]],[\"comment/160\",[]],[\"name/161\",[88,49.11]],[\"comment/161\",[]],[\"name/162\",[89,49.11]],[\"comment/162\",[]],[\"name/163\",[90,49.11]],[\"comment/163\",[]],[\"name/164\",[91,49.11]],[\"comment/164\",[]],[\"name/165\",[92,49.11]],[\"comment/165\",[]],[\"name/166\",[93,49.11]],[\"comment/166\",[]],[\"name/167\",[54,45.433]],[\"comment/167\",[]],[\"name/168\",[94,49.11]],[\"comment/168\",[]],[\"name/169\",[95,49.11]],[\"comment/169\",[]],[\"name/170\",[96,49.11]],[\"comment/170\",[]],[\"name/171\",[97,49.11]],[\"comment/171\",[]],[\"name/172\",[85,45.433]],[\"comment/172\",[]],[\"name/173\",[5,47.103]],[\"comment/173\",[]],[\"name/174\",[8,49.11]],[\"comment/174\",[]],[\"name/175\",[7,49.11]],[\"comment/175\",[]],[\"name/176\",[9,54.988]],[\"comment/176\",[]],[\"name/177\",[10,54.988]],[\"comment/177\",[]],[\"name/178\",[11,54.988]],[\"comment/178\",[]],[\"name/179\",[12,45.433]],[\"comment/179\",[]],[\"name/180\",[13,13.122]],[\"comment/180\",[]],[\"name/181\",[14,54.988]],[\"comment/181\",[]],[\"name/182\",[15,54.988]],[\"comment/182\",[]],[\"name/183\",[16,54.988]],[\"comment/183\",[]],[\"name/184\",[17,54.988]],[\"comment/184\",[]],[\"name/185\",[13,13.122]],[\"comment/185\",[]],[\"name/186\",[18,49.11]],[\"comment/186\",[]],[\"name/187\",[13,13.122]],[\"comment/187\",[]],[\"name/188\",[98,54.988]],[\"comment/188\",[]],[\"name/189\",[13,13.122]],[\"comment/189\",[]],[\"name/190\",[19,49.11]],[\"comment/190\",[]],[\"name/191\",[13,13.122]],[\"comment/191\",[]],[\"name/192\",[20,42.75]],[\"comment/192\",[]],[\"name/193\",[13,13.122]],[\"comment/193\",[]],[\"name/194\",[99,51.623]],[\"comment/194\",[]],[\"name/195\",[13,13.122]],[\"comment/195\",[]],[\"name/196\",[21,49.11]],[\"comment/196\",[]],[\"name/197\",[13,13.122]],[\"comment/197\",[]],[\"name/198\",[100,54.988]],[\"comment/198\",[]],[\"name/199\",[13,13.122]],[\"comment/199\",[]],[\"name/200\",[22,45.433]],[\"comment/200\",[]],[\"name/201\",[13,13.122]],[\"comment/201\",[]],[\"name/202\",[23,49.11]],[\"comment/202\",[]],[\"name/203\",[13,13.122]],[\"comment/203\",[]],[\"name/204\",[101,54.988]],[\"comment/204\",[]],[\"name/205\",[13,13.122]],[\"comment/205\",[]],[\"name/206\",[24,49.11]],[\"comment/206\",[]],[\"name/207\",[13,13.122]],[\"comment/207\",[]],[\"name/208\",[102,54.988]],[\"comment/208\",[]],[\"name/209\",[13,13.122]],[\"comment/209\",[]],[\"name/210\",[103,54.988]],[\"comment/210\",[]],[\"name/211\",[13,13.122]],[\"comment/211\",[]],[\"name/212\",[25,49.11]],[\"comment/212\",[]],[\"name/213\",[13,13.122]],[\"comment/213\",[]],[\"name/214\",[26,49.11]],[\"comment/214\",[]],[\"name/215\",[13,13.122]],[\"comment/215\",[]],[\"name/216\",[27,49.11]],[\"comment/216\",[]],[\"name/217\",[13,13.122]],[\"comment/217\",[]],[\"name/218\",[28,49.11]],[\"comment/218\",[]],[\"name/219\",[13,13.122]],[\"comment/219\",[]],[\"name/220\",[29,49.11]],[\"comment/220\",[]],[\"name/221\",[13,13.122]],[\"comment/221\",[]],[\"name/222\",[30,49.11]],[\"comment/222\",[]],[\"name/223\",[13,13.122]],[\"comment/223\",[]],[\"name/224\",[31,49.11]],[\"comment/224\",[]],[\"name/225\",[13,13.122]],[\"comment/225\",[]],[\"name/226\",[32,49.11]],[\"comment/226\",[]],[\"name/227\",[13,13.122]],[\"comment/227\",[]],[\"name/228\",[33,49.11]],[\"comment/228\",[]],[\"name/229\",[13,13.122]],[\"comment/229\",[]],[\"name/230\",[104,51.623]],[\"comment/230\",[]],[\"name/231\",[13,13.122]],[\"comment/231\",[]],[\"name/232\",[35,49.11]],[\"comment/232\",[]],[\"name/233\",[13,13.122]],[\"comment/233\",[]],[\"name/234\",[36,49.11]],[\"comment/234\",[]],[\"name/235\",[13,13.122]],[\"comment/235\",[]],[\"name/236\",[37,49.11]],[\"comment/236\",[]],[\"name/237\",[13,13.122]],[\"comment/237\",[]],[\"name/238\",[38,49.11]],[\"comment/238\",[]],[\"name/239\",[13,13.122]],[\"comment/239\",[]],[\"name/240\",[39,49.11]],[\"comment/240\",[]],[\"name/241\",[13,13.122]],[\"comment/241\",[]],[\"name/242\",[105,51.623]],[\"comment/242\",[]],[\"name/243\",[13,13.122]],[\"comment/243\",[]],[\"name/244\",[40,49.11]],[\"comment/244\",[]],[\"name/245\",[13,13.122]],[\"comment/245\",[]],[\"name/246\",[41,49.11]],[\"comment/246\",[]],[\"name/247\",[13,13.122]],[\"comment/247\",[]],[\"name/248\",[42,49.11]],[\"comment/248\",[]],[\"name/249\",[13,13.122]],[\"comment/249\",[]],[\"name/250\",[43,49.11]],[\"comment/250\",[]],[\"name/251\",[13,13.122]],[\"comment/251\",[]],[\"name/252\",[44,49.11]],[\"comment/252\",[]],[\"name/253\",[13,13.122]],[\"comment/253\",[]],[\"name/254\",[45,49.11]],[\"comment/254\",[]],[\"name/255\",[13,13.122]],[\"comment/255\",[]],[\"name/256\",[46,49.11]],[\"comment/256\",[]],[\"name/257\",[13,13.122]],[\"comment/257\",[]],[\"name/258\",[47,49.11]],[\"comment/258\",[]],[\"name/259\",[13,13.122]],[\"comment/259\",[]],[\"name/260\",[48,49.11]],[\"comment/260\",[]],[\"name/261\",[13,13.122]],[\"comment/261\",[]],[\"name/262\",[49,49.11]],[\"comment/262\",[]],[\"name/263\",[13,13.122]],[\"comment/263\",[]],[\"name/264\",[50,49.11]],[\"comment/264\",[]],[\"name/265\",[13,13.122]],[\"comment/265\",[]],[\"name/266\",[51,49.11]],[\"comment/266\",[]],[\"name/267\",[13,13.122]],[\"comment/267\",[]],[\"name/268\",[106,54.988]],[\"comment/268\",[]],[\"name/269\",[13,13.122]],[\"comment/269\",[]],[\"name/270\",[107,51.623]],[\"comment/270\",[]],[\"name/271\",[13,13.122]],[\"comment/271\",[]],[\"name/272\",[52,49.11]],[\"comment/272\",[]],[\"name/273\",[13,13.122]],[\"comment/273\",[]],[\"name/274\",[53,49.11]],[\"comment/274\",[]],[\"name/275\",[13,13.122]],[\"comment/275\",[]],[\"name/276\",[54,45.433]],[\"comment/276\",[]],[\"name/277\",[13,13.122]],[\"comment/277\",[]],[\"name/278\",[55,49.11]],[\"comment/278\",[]],[\"name/279\",[13,13.122]],[\"comment/279\",[]],[\"name/280\",[56,49.11]],[\"comment/280\",[]],[\"name/281\",[13,13.122]],[\"comment/281\",[]],[\"name/282\",[57,49.11]],[\"comment/282\",[]],[\"name/283\",[13,13.122]],[\"comment/283\",[]],[\"name/284\",[58,49.11]],[\"comment/284\",[]],[\"name/285\",[13,13.122]],[\"comment/285\",[]],[\"name/286\",[59,49.11]],[\"comment/286\",[]],[\"name/287\",[13,13.122]],[\"comment/287\",[]],[\"name/288\",[108,54.988]],[\"comment/288\",[]],[\"name/289\",[13,13.122]],[\"comment/289\",[]],[\"name/290\",[109,54.988]],[\"comment/290\",[]],[\"name/291\",[13,13.122]],[\"comment/291\",[]],[\"name/292\",[60,49.11]],[\"comment/292\",[]],[\"name/293\",[13,13.122]],[\"comment/293\",[]],[\"name/294\",[61,49.11]],[\"comment/294\",[]],[\"name/295\",[13,13.122]],[\"comment/295\",[]],[\"name/296\",[62,49.11]],[\"comment/296\",[]],[\"name/297\",[13,13.122]],[\"comment/297\",[]],[\"name/298\",[63,49.11]],[\"comment/298\",[]],[\"name/299\",[13,13.122]],[\"comment/299\",[]],[\"name/300\",[64,49.11]],[\"comment/300\",[]],[\"name/301\",[13,13.122]],[\"comment/301\",[]],[\"name/302\",[65,49.11]],[\"comment/302\",[]],[\"name/303\",[13,13.122]],[\"comment/303\",[]],[\"name/304\",[66,49.11]],[\"comment/304\",[]],[\"name/305\",[13,13.122]],[\"comment/305\",[]],[\"name/306\",[67,49.11]],[\"comment/306\",[]],[\"name/307\",[13,13.122]],[\"comment/307\",[]],[\"name/308\",[68,49.11]],[\"comment/308\",[]],[\"name/309\",[13,13.122]],[\"comment/309\",[]],[\"name/310\",[69,49.11]],[\"comment/310\",[]],[\"name/311\",[13,13.122]],[\"comment/311\",[]],[\"name/312\",[70,49.11]],[\"comment/312\",[]],[\"name/313\",[13,13.122]],[\"comment/313\",[]],[\"name/314\",[71,49.11]],[\"comment/314\",[]],[\"name/315\",[13,13.122]],[\"comment/315\",[]],[\"name/316\",[110,54.988]],[\"comment/316\",[]],[\"name/317\",[13,13.122]],[\"comment/317\",[]],[\"name/318\",[72,49.11]],[\"comment/318\",[]],[\"name/319\",[13,13.122]],[\"comment/319\",[]],[\"name/320\",[73,49.11]],[\"comment/320\",[]],[\"name/321\",[13,13.122]],[\"comment/321\",[]],[\"name/322\",[74,49.11]],[\"comment/322\",[]],[\"name/323\",[13,13.122]],[\"comment/323\",[]],[\"name/324\",[75,49.11]],[\"comment/324\",[]],[\"name/325\",[13,13.122]],[\"comment/325\",[]],[\"name/326\",[76,49.11]],[\"comment/326\",[]],[\"name/327\",[13,13.122]],[\"comment/327\",[]],[\"name/328\",[77,49.11]],[\"comment/328\",[]],[\"name/329\",[13,13.122]],[\"comment/329\",[]],[\"name/330\",[78,49.11]],[\"comment/330\",[]],[\"name/331\",[13,13.122]],[\"comment/331\",[]],[\"name/332\",[111,54.988]],[\"comment/332\",[]],[\"name/333\",[13,13.122]],[\"comment/333\",[]],[\"name/334\",[79,49.11]],[\"comment/334\",[]],[\"name/335\",[13,13.122]],[\"comment/335\",[]],[\"name/336\",[80,49.11]],[\"comment/336\",[]],[\"name/337\",[13,13.122]],[\"comment/337\",[]],[\"name/338\",[112,54.988]],[\"comment/338\",[]],[\"name/339\",[13,13.122]],[\"comment/339\",[]],[\"name/340\",[81,49.11]],[\"comment/340\",[]],[\"name/341\",[13,13.122]],[\"comment/341\",[]],[\"name/342\",[82,49.11]],[\"comment/342\",[]],[\"name/343\",[13,13.122]],[\"comment/343\",[]],[\"name/344\",[113,54.988]],[\"comment/344\",[]],[\"name/345\",[13,13.122]],[\"comment/345\",[]],[\"name/346\",[83,49.11]],[\"comment/346\",[]],[\"name/347\",[13,13.122]],[\"comment/347\",[]],[\"name/348\",[84,49.11]],[\"comment/348\",[]],[\"name/349\",[13,13.122]],[\"comment/349\",[]],[\"name/350\",[114,54.988]],[\"comment/350\",[]],[\"name/351\",[13,13.122]],[\"comment/351\",[]],[\"name/352\",[85,45.433]],[\"comment/352\",[]],[\"name/353\",[13,13.122]],[\"comment/353\",[]],[\"name/354\",[115,60.096]],[\"comment/354\",[]],[\"name/355\",[5,47.103]],[\"comment/355\",[]],[\"name/356\",[116,54.988]],[\"comment/356\",[]],[\"name/357\",[13,13.122]],[\"comment/357\",[]],[\"name/358\",[117,54.988]],[\"comment/358\",[]],[\"name/359\",[13,13.122]],[\"comment/359\",[]],[\"name/360\",[87,49.11]],[\"comment/360\",[]],[\"name/361\",[20,42.75]],[\"comment/361\",[]],[\"name/362\",[99,51.623]],[\"comment/362\",[]],[\"name/363\",[22,45.433]],[\"comment/363\",[]],[\"name/364\",[88,49.11]],[\"comment/364\",[]],[\"name/365\",[89,49.11]],[\"comment/365\",[]],[\"name/366\",[90,49.11]],[\"comment/366\",[]],[\"name/367\",[105,51.623]],[\"comment/367\",[]],[\"name/368\",[118,51.623]],[\"comment/368\",[]],[\"name/369\",[119,54.988]],[\"comment/369\",[]],[\"name/370\",[120,54.988]],[\"comment/370\",[]],[\"name/371\",[121,54.988]],[\"comment/371\",[]],[\"name/372\",[122,54.988]],[\"comment/372\",[]],[\"name/373\",[91,49.11]],[\"comment/373\",[]],[\"name/374\",[92,49.11]],[\"comment/374\",[]],[\"name/375\",[107,51.623]],[\"comment/375\",[]],[\"name/376\",[123,54.988]],[\"comment/376\",[]],[\"name/377\",[93,49.11]],[\"comment/377\",[]],[\"name/378\",[54,45.433]],[\"comment/378\",[]],[\"name/379\",[124,54.988]],[\"comment/379\",[]],[\"name/380\",[94,49.11]],[\"comment/380\",[]],[\"name/381\",[95,49.11]],[\"comment/381\",[]],[\"name/382\",[96,49.11]],[\"comment/382\",[]],[\"name/383\",[97,49.11]],[\"comment/383\",[]],[\"name/384\",[85,45.433]],[\"comment/384\",[]],[\"name/385\",[118,51.623]],[\"comment/385\",[]],[\"name/386\",[3,47.103]],[\"comment/386\",[]],[\"name/387\",[5,47.103]],[\"comment/387\",[]],[\"name/388\",[121,54.988]],[\"comment/388\",[]],[\"name/389\",[3,47.103]],[\"comment/389\",[]],[\"name/390\",[5,47.103]],[\"comment/390\",[]],[\"name/391\",[18,49.11]],[\"comment/391\",[]],[\"name/392\",[87,49.11]],[\"comment/392\",[]],[\"name/393\",[20,42.75]],[\"comment/393\",[]],[\"name/394\",[22,45.433]],[\"comment/394\",[]],[\"name/395\",[23,49.11]],[\"comment/395\",[]],[\"name/396\",[88,49.11]],[\"comment/396\",[]],[\"name/397\",[89,49.11]],[\"comment/397\",[]],[\"name/398\",[28,49.11]],[\"comment/398\",[]],[\"name/399\",[90,49.11]],[\"comment/399\",[]],[\"name/400\",[30,49.11]],[\"comment/400\",[]],[\"name/401\",[35,49.11]],[\"comment/401\",[]],[\"name/402\",[36,49.11]],[\"comment/402\",[]],[\"name/403\",[37,49.11]],[\"comment/403\",[]],[\"name/404\",[91,49.11]],[\"comment/404\",[]],[\"name/405\",[92,49.11]],[\"comment/405\",[]],[\"name/406\",[43,49.11]],[\"comment/406\",[]],[\"name/407\",[46,49.11]],[\"comment/407\",[]],[\"name/408\",[125,60.096]],[\"comment/408\",[]],[\"name/409\",[7,49.11]],[\"comment/409\",[]],[\"name/410\",[8,49.11]],[\"comment/410\",[]],[\"name/411\",[47,49.11]],[\"comment/411\",[]],[\"name/412\",[50,49.11]],[\"comment/412\",[]],[\"name/413\",[49,49.11]],[\"comment/413\",[]],[\"name/414\",[53,49.11]],[\"comment/414\",[]],[\"name/415\",[52,49.11]],[\"comment/415\",[]],[\"name/416\",[93,49.11]],[\"comment/416\",[]],[\"name/417\",[54,45.433]],[\"comment/417\",[]],[\"name/418\",[94,49.11]],[\"comment/418\",[]],[\"name/419\",[60,49.11]],[\"comment/419\",[]],[\"name/420\",[61,49.11]],[\"comment/420\",[]],[\"name/421\",[95,49.11]],[\"comment/421\",[]],[\"name/422\",[67,49.11]],[\"comment/422\",[]],[\"name/423\",[69,49.11]],[\"comment/423\",[]],[\"name/424\",[74,49.11]],[\"comment/424\",[]],[\"name/425\",[76,49.11]],[\"comment/425\",[]],[\"name/426\",[96,49.11]],[\"comment/426\",[]],[\"name/427\",[81,49.11]],[\"comment/427\",[]],[\"name/428\",[12,45.433]],[\"comment/428\",[]],[\"name/429\",[82,49.11]],[\"comment/429\",[]],[\"name/430\",[83,49.11]],[\"comment/430\",[]],[\"name/431\",[97,49.11]],[\"comment/431\",[]],[\"name/432\",[85,45.433]],[\"comment/432\",[]],[\"name/433\",[19,49.11]],[\"comment/433\",[]],[\"name/434\",[20,42.75]],[\"comment/434\",[]],[\"name/435\",[21,49.11]],[\"comment/435\",[]],[\"name/436\",[126,54.988]],[\"comment/436\",[]],[\"name/437\",[24,49.11]],[\"comment/437\",[]],[\"name/438\",[25,49.11]],[\"comment/438\",[]],[\"name/439\",[26,49.11]],[\"comment/439\",[]],[\"name/440\",[27,49.11]],[\"comment/440\",[]],[\"name/441\",[29,49.11]],[\"comment/441\",[]],[\"name/442\",[31,49.11]],[\"comment/442\",[]],[\"name/443\",[32,49.11]],[\"comment/443\",[]],[\"name/444\",[33,49.11]],[\"comment/444\",[]],[\"name/445\",[104,51.623]],[\"comment/445\",[]],[\"name/446\",[38,49.11]],[\"comment/446\",[]],[\"name/447\",[39,49.11]],[\"comment/447\",[]],[\"name/448\",[40,49.11]],[\"comment/448\",[]],[\"name/449\",[41,49.11]],[\"comment/449\",[]],[\"name/450\",[42,49.11]],[\"comment/450\",[]],[\"name/451\",[44,49.11]],[\"comment/451\",[]],[\"name/452\",[45,49.11]],[\"comment/452\",[]],[\"name/453\",[48,49.11]],[\"comment/453\",[]],[\"name/454\",[51,49.11]],[\"comment/454\",[]],[\"name/455\",[55,49.11]],[\"comment/455\",[]],[\"name/456\",[56,49.11]],[\"comment/456\",[]],[\"name/457\",[127,54.988]],[\"comment/457\",[]],[\"name/458\",[128,54.988]],[\"comment/458\",[]],[\"name/459\",[57,49.11]],[\"comment/459\",[]],[\"name/460\",[58,49.11]],[\"comment/460\",[]],[\"name/461\",[59,49.11]],[\"comment/461\",[]],[\"name/462\",[62,49.11]],[\"comment/462\",[]],[\"name/463\",[63,49.11]],[\"comment/463\",[]],[\"name/464\",[64,49.11]],[\"comment/464\",[]],[\"name/465\",[65,49.11]],[\"comment/465\",[]],[\"name/466\",[66,49.11]],[\"comment/466\",[]],[\"name/467\",[68,49.11]],[\"comment/467\",[]],[\"name/468\",[70,49.11]],[\"comment/468\",[]],[\"name/469\",[71,49.11]],[\"comment/469\",[]],[\"name/470\",[72,49.11]],[\"comment/470\",[]],[\"name/471\",[73,49.11]],[\"comment/471\",[]],[\"name/472\",[75,49.11]],[\"comment/472\",[]],[\"name/473\",[77,49.11]],[\"comment/473\",[]],[\"name/474\",[78,49.11]],[\"comment/474\",[]],[\"name/475\",[79,49.11]],[\"comment/475\",[]],[\"name/476\",[80,49.11]],[\"comment/476\",[]],[\"name/477\",[12,45.433]],[\"comment/477\",[]],[\"name/478\",[84,49.11]],[\"comment/478\",[]],[\"name/479\",[129,54.988]],[\"comment/479\",[]],[\"name/480\",[116,54.988]],[\"comment/480\",[]],[\"name/481\",[13,13.122]],[\"comment/481\",[]],[\"name/482\",[117,54.988]],[\"comment/482\",[]],[\"name/483\",[13,13.122]],[\"comment/483\",[]],[\"name/484\",[130,60.096]],[\"comment/484\",[]],[\"name/485\",[7,49.11]],[\"comment/485\",[]],[\"name/486\",[8,49.11]],[\"comment/486\",[]],[\"name/487\",[18,49.11]],[\"comment/487\",[]],[\"name/488\",[87,49.11]],[\"comment/488\",[]],[\"name/489\",[20,42.75]],[\"comment/489\",[]],[\"name/490\",[99,51.623]],[\"comment/490\",[]],[\"name/491\",[22,45.433]],[\"comment/491\",[]],[\"name/492\",[131,60.096]],[\"comment/492\",[]],[\"name/493\",[23,49.11]],[\"comment/493\",[]],[\"name/494\",[88,49.11]],[\"comment/494\",[]],[\"name/495\",[89,49.11]],[\"comment/495\",[]],[\"name/496\",[28,49.11]],[\"comment/496\",[]],[\"name/497\",[90,49.11]],[\"comment/497\",[]],[\"name/498\",[30,49.11]],[\"comment/498\",[]],[\"name/499\",[35,49.11]],[\"comment/499\",[]],[\"name/500\",[36,49.11]],[\"comment/500\",[]],[\"name/501\",[37,49.11]],[\"comment/501\",[]],[\"name/502\",[105,51.623]],[\"comment/502\",[]],[\"name/503\",[118,51.623]],[\"comment/503\",[]],[\"name/504\",[119,54.988]],[\"comment/504\",[]],[\"name/505\",[120,54.988]],[\"comment/505\",[]],[\"name/506\",[91,49.11]],[\"comment/506\",[]],[\"name/507\",[122,54.988]],[\"comment/507\",[]],[\"name/508\",[92,49.11]],[\"comment/508\",[]],[\"name/509\",[43,49.11]],[\"comment/509\",[]],[\"name/510\",[132,60.096]],[\"comment/510\",[]],[\"name/511\",[46,49.11]],[\"comment/511\",[]],[\"name/512\",[47,49.11]],[\"comment/512\",[]],[\"name/513\",[50,49.11]],[\"comment/513\",[]],[\"name/514\",[49,49.11]],[\"comment/514\",[]],[\"name/515\",[107,51.623]],[\"comment/515\",[]],[\"name/516\",[53,49.11]],[\"comment/516\",[]],[\"name/517\",[52,49.11]],[\"comment/517\",[]],[\"name/518\",[123,54.988]],[\"comment/518\",[]],[\"name/519\",[93,49.11]],[\"comment/519\",[]],[\"name/520\",[54,45.433]],[\"comment/520\",[]],[\"name/521\",[124,54.988]],[\"comment/521\",[]],[\"name/522\",[94,49.11]],[\"comment/522\",[]],[\"name/523\",[60,49.11]],[\"comment/523\",[]],[\"name/524\",[61,49.11]],[\"comment/524\",[]],[\"name/525\",[95,49.11]],[\"comment/525\",[]],[\"name/526\",[67,49.11]],[\"comment/526\",[]],[\"name/527\",[69,49.11]],[\"comment/527\",[]],[\"name/528\",[74,49.11]],[\"comment/528\",[]],[\"name/529\",[76,49.11]],[\"comment/529\",[]],[\"name/530\",[96,49.11]],[\"comment/530\",[]],[\"name/531\",[81,49.11]],[\"comment/531\",[]],[\"name/532\",[12,45.433]],[\"comment/532\",[]],[\"name/533\",[82,49.11]],[\"comment/533\",[]],[\"name/534\",[113,54.988]],[\"comment/534\",[]],[\"name/535\",[83,49.11]],[\"comment/535\",[]],[\"name/536\",[97,49.11]],[\"comment/536\",[]],[\"name/537\",[85,45.433]],[\"comment/537\",[]],[\"name/538\",[98,54.988]],[\"comment/538\",[]],[\"name/539\",[19,49.11]],[\"comment/539\",[]],[\"name/540\",[133,60.096]],[\"comment/540\",[]],[\"name/541\",[20,42.75]],[\"comment/541\",[]],[\"name/542\",[134,60.096]],[\"comment/542\",[]],[\"name/543\",[21,49.11]],[\"comment/543\",[]],[\"name/544\",[100,54.988]],[\"comment/544\",[]],[\"name/545\",[126,54.988]],[\"comment/545\",[]],[\"name/546\",[101,54.988]],[\"comment/546\",[]],[\"name/547\",[24,49.11]],[\"comment/547\",[]],[\"name/548\",[102,54.988]],[\"comment/548\",[]],[\"name/549\",[103,54.988]],[\"comment/549\",[]],[\"name/550\",[25,49.11]],[\"comment/550\",[]],[\"name/551\",[26,49.11]],[\"comment/551\",[]],[\"name/552\",[27,49.11]],[\"comment/552\",[]],[\"name/553\",[29,49.11]],[\"comment/553\",[]],[\"name/554\",[31,49.11]],[\"comment/554\",[]],[\"name/555\",[32,49.11]],[\"comment/555\",[]],[\"name/556\",[33,49.11]],[\"comment/556\",[]],[\"name/557\",[104,51.623]],[\"comment/557\",[]],[\"name/558\",[38,49.11]],[\"comment/558\",[]],[\"name/559\",[39,49.11]],[\"comment/559\",[]],[\"name/560\",[13,13.122]],[\"comment/560\",[]],[\"name/561\",[40,49.11]],[\"comment/561\",[]],[\"name/562\",[41,49.11]],[\"comment/562\",[]],[\"name/563\",[42,49.11]],[\"comment/563\",[]],[\"name/564\",[44,49.11]],[\"comment/564\",[]],[\"name/565\",[45,49.11]],[\"comment/565\",[]],[\"name/566\",[48,49.11]],[\"comment/566\",[]],[\"name/567\",[51,49.11]],[\"comment/567\",[]],[\"name/568\",[106,54.988]],[\"comment/568\",[]],[\"name/569\",[13,13.122]],[\"comment/569\",[]],[\"name/570\",[135,60.096]],[\"comment/570\",[]],[\"name/571\",[55,49.11]],[\"comment/571\",[]],[\"name/572\",[56,49.11]],[\"comment/572\",[]],[\"name/573\",[127,54.988]],[\"comment/573\",[]],[\"name/574\",[128,54.988]],[\"comment/574\",[]],[\"name/575\",[57,49.11]],[\"comment/575\",[]],[\"name/576\",[58,49.11]],[\"comment/576\",[]],[\"name/577\",[59,49.11]],[\"comment/577\",[]],[\"name/578\",[136,60.096]],[\"comment/578\",[]],[\"name/579\",[62,49.11]],[\"comment/579\",[]],[\"name/580\",[63,49.11]],[\"comment/580\",[]],[\"name/581\",[64,49.11]],[\"comment/581\",[]],[\"name/582\",[65,49.11]],[\"comment/582\",[]],[\"name/583\",[66,49.11]],[\"comment/583\",[]],[\"name/584\",[68,49.11]],[\"comment/584\",[]],[\"name/585\",[70,49.11]],[\"comment/585\",[]],[\"name/586\",[71,49.11]],[\"comment/586\",[]],[\"name/587\",[110,54.988]],[\"comment/587\",[]],[\"name/588\",[72,49.11]],[\"comment/588\",[]],[\"name/589\",[73,49.11]],[\"comment/589\",[]],[\"name/590\",[75,49.11]],[\"comment/590\",[]],[\"name/591\",[13,13.122]],[\"comment/591\",[]],[\"name/592\",[108,54.988]],[\"comment/592\",[]],[\"name/593\",[13,13.122]],[\"comment/593\",[]],[\"name/594\",[109,54.988]],[\"comment/594\",[]],[\"name/595\",[77,49.11]],[\"comment/595\",[]],[\"name/596\",[78,49.11]],[\"comment/596\",[]],[\"name/597\",[111,54.988]],[\"comment/597\",[]],[\"name/598\",[79,49.11]],[\"comment/598\",[]],[\"name/599\",[80,49.11]],[\"comment/599\",[]],[\"name/600\",[112,54.988]],[\"comment/600\",[]],[\"name/601\",[137,60.096]],[\"comment/601\",[]],[\"name/602\",[138,60.096]],[\"comment/602\",[]],[\"name/603\",[139,60.096]],[\"comment/603\",[]],[\"name/604\",[12,45.433]],[\"comment/604\",[]],[\"name/605\",[84,49.11]],[\"comment/605\",[]],[\"name/606\",[140,60.096]],[\"comment/606\",[]],[\"name/607\",[141,60.096]],[\"comment/607\",[]],[\"name/608\",[114,54.988]],[\"comment/608\",[]],[\"name/609\",[129,54.988]],[\"comment/609\",[]]],\"invertedIndex\":[[\"__type\",{\"_index\":13,\"name\":{\"14\":{},\"19\":{},\"21\":{},\"23\":{},\"25\":{},\"27\":{},\"29\":{},\"31\":{},\"33\":{},\"35\":{},\"37\":{},\"39\":{},\"41\":{},\"43\":{},\"45\":{},\"47\":{},\"49\":{},\"51\":{},\"53\":{},\"55\":{},\"57\":{},\"59\":{},\"61\":{},\"63\":{},\"65\":{},\"67\":{},\"69\":{},\"71\":{},\"73\":{},\"75\":{},\"77\":{},\"79\":{},\"81\":{},\"83\":{},\"85\":{},\"87\":{},\"89\":{},\"91\":{},\"93\":{},\"95\":{},\"97\":{},\"99\":{},\"101\":{},\"103\":{},\"105\":{},\"107\":{},\"109\":{},\"111\":{},\"113\":{},\"115\":{},\"117\":{},\"119\":{},\"121\":{},\"123\":{},\"125\":{},\"127\":{},\"129\":{},\"131\":{},\"133\":{},\"135\":{},\"137\":{},\"139\":{},\"141\":{},\"143\":{},\"145\":{},\"147\":{},\"149\":{},\"151\":{},\"153\":{},\"155\":{},\"180\":{},\"185\":{},\"187\":{},\"189\":{},\"191\":{},\"193\":{},\"195\":{},\"197\":{},\"199\":{},\"201\":{},\"203\":{},\"205\":{},\"207\":{},\"209\":{},\"211\":{},\"213\":{},\"215\":{},\"217\":{},\"219\":{},\"221\":{},\"223\":{},\"225\":{},\"227\":{},\"229\":{},\"231\":{},\"233\":{},\"235\":{},\"237\":{},\"239\":{},\"241\":{},\"243\":{},\"245\":{},\"247\":{},\"249\":{},\"251\":{},\"253\":{},\"255\":{},\"257\":{},\"259\":{},\"261\":{},\"263\":{},\"265\":{},\"267\":{},\"269\":{},\"271\":{},\"273\":{},\"275\":{},\"277\":{},\"279\":{},\"281\":{},\"283\":{},\"285\":{},\"287\":{},\"289\":{},\"291\":{},\"293\":{},\"295\":{},\"297\":{},\"299\":{},\"301\":{},\"303\":{},\"305\":{},\"307\":{},\"309\":{},\"311\":{},\"313\":{},\"315\":{},\"317\":{},\"319\":{},\"321\":{},\"323\":{},\"325\":{},\"327\":{},\"329\":{},\"331\":{},\"333\":{},\"335\":{},\"337\":{},\"339\":{},\"341\":{},\"343\":{},\"345\":{},\"347\":{},\"349\":{},\"351\":{},\"353\":{},\"357\":{},\"359\":{},\"481\":{},\"483\":{},\"560\":{},\"569\":{},\"591\":{},\"593\":{}},\"comment\":{}}],[\"_concatall\",{\"_index\":131,\"name\":{\"492\":{}},\"comment\":{}}],[\"as\",{\"_index\":7,\"name\":{\"8\":{},\"175\":{},\"409\":{},\"485\":{}},\"comment\":{}}],[\"asyncify\",{\"_index\":117,\"name\":{\"358\":{},\"482\":{}},\"comment\":{}}],[\"asyncifyerrback\",{\"_index\":116,\"name\":{\"356\":{},\"480\":{}},\"comment\":{}}],[\"asynciterable\",{\"_index\":5,\"name\":{\"5\":{},\"173\":{},\"355\":{},\"387\":{},\"390\":{}},\"comment\":{}}],[\"asynciterable/operators\",{\"_index\":6,\"name\":{\"6\":{}},\"comment\":{}}],[\"asynciterablex\",{\"_index\":130,\"name\":{\"484\":{}},\"comment\":{}}],[\"asynciterator\",{\"_index\":115,\"name\":{\"354\":{}},\"comment\":{}}],[\"average\",{\"_index\":18,\"name\":{\"20\":{},\"186\":{},\"391\":{},\"487\":{}},\"comment\":{}}],[\"batch\",{\"_index\":98,\"name\":{\"188\":{},\"538\":{}},\"comment\":{}}],[\"buffer\",{\"_index\":19,\"name\":{\"22\":{},\"190\":{},\"433\":{},\"539\":{}},\"comment\":{}}],[\"buffercountortime\",{\"_index\":133,\"name\":{\"540\":{}},\"comment\":{}}],[\"catchall\",{\"_index\":87,\"name\":{\"158\":{},\"360\":{},\"392\":{},\"488\":{}},\"comment\":{}}],[\"catcherror\",{\"_index\":20,\"name\":{\"24\":{},\"159\":{},\"192\":{},\"361\":{},\"393\":{},\"434\":{},\"489\":{},\"541\":{}},\"comment\":{}}],[\"combinelatest\",{\"_index\":99,\"name\":{\"194\":{},\"362\":{},\"490\":{}},\"comment\":{}}],[\"combinelatestwith\",{\"_index\":134,\"name\":{\"542\":{}},\"comment\":{}}],[\"concat\",{\"_index\":22,\"name\":{\"28\":{},\"160\":{},\"200\":{},\"363\":{},\"394\":{},\"491\":{}},\"comment\":{}}],[\"concatall\",{\"_index\":21,\"name\":{\"26\":{},\"196\":{},\"435\":{},\"543\":{}},\"comment\":{}}],[\"concatmap\",{\"_index\":100,\"name\":{\"198\":{},\"544\":{}},\"comment\":{}}],[\"concatwith\",{\"_index\":126,\"name\":{\"436\":{},\"545\":{}},\"comment\":{}}],[\"constructor\",{\"_index\":9,\"name\":{\"10\":{},\"176\":{}},\"comment\":{}}],[\"count\",{\"_index\":23,\"name\":{\"30\":{},\"202\":{},\"395\":{},\"493\":{}},\"comment\":{}}],[\"create\",{\"_index\":88,\"name\":{\"161\":{},\"364\":{},\"396\":{},\"494\":{}},\"comment\":{}}],[\"debounce\",{\"_index\":101,\"name\":{\"204\":{},\"546\":{}},\"comment\":{}}],[\"defaultifempty\",{\"_index\":24,\"name\":{\"32\":{},\"206\":{},\"437\":{},\"547\":{}},\"comment\":{}}],[\"defer\",{\"_index\":89,\"name\":{\"162\":{},\"365\":{},\"397\":{},\"495\":{}},\"comment\":{}}],[\"delay\",{\"_index\":103,\"name\":{\"210\":{},\"549\":{}},\"comment\":{}}],[\"delayeach\",{\"_index\":102,\"name\":{\"208\":{},\"548\":{}},\"comment\":{}}],[\"distinct\",{\"_index\":25,\"name\":{\"34\":{},\"212\":{},\"438\":{},\"550\":{}},\"comment\":{}}],[\"distinctuntilchanged\",{\"_index\":26,\"name\":{\"36\":{},\"214\":{},\"439\":{},\"551\":{}},\"comment\":{}}],[\"dom\",{\"_index\":1,\"name\":{\"1\":{}},\"comment\":{}}],[\"dowhile\",{\"_index\":27,\"name\":{\"38\":{},\"216\":{},\"440\":{},\"552\":{}},\"comment\":{}}],[\"elementat\",{\"_index\":28,\"name\":{\"40\":{},\"218\":{},\"398\":{},\"496\":{}},\"comment\":{}}],[\"empty\",{\"_index\":90,\"name\":{\"163\":{},\"366\":{},\"399\":{},\"497\":{}},\"comment\":{}}],[\"endwith\",{\"_index\":29,\"name\":{\"42\":{},\"220\":{},\"441\":{},\"553\":{}},\"comment\":{}}],[\"every\",{\"_index\":30,\"name\":{\"44\":{},\"222\":{},\"400\":{},\"498\":{}},\"comment\":{}}],[\"except\",{\"_index\":31,\"name\":{\"46\":{},\"224\":{},\"442\":{},\"554\":{}},\"comment\":{}}],[\"expand\",{\"_index\":32,\"name\":{\"48\":{},\"226\":{},\"443\":{},\"555\":{}},\"comment\":{}}],[\"filter\",{\"_index\":33,\"name\":{\"50\":{},\"228\":{},\"444\":{},\"556\":{}},\"comment\":{}}],[\"finalize\",{\"_index\":104,\"name\":{\"230\":{},\"445\":{},\"557\":{}},\"comment\":{}}],[\"finally\",{\"_index\":34,\"name\":{\"52\":{}},\"comment\":{}}],[\"find\",{\"_index\":36,\"name\":{\"56\":{},\"234\":{},\"402\":{},\"500\":{}},\"comment\":{}}],[\"findindex\",{\"_index\":35,\"name\":{\"54\":{},\"232\":{},\"401\":{},\"499\":{}},\"comment\":{}}],[\"first\",{\"_index\":37,\"name\":{\"58\":{},\"236\":{},\"403\":{},\"501\":{}},\"comment\":{}}],[\"flat\",{\"_index\":39,\"name\":{\"62\":{},\"240\":{},\"447\":{},\"559\":{}},\"comment\":{}}],[\"flatmap\",{\"_index\":38,\"name\":{\"60\":{},\"238\":{},\"446\":{},\"558\":{}},\"comment\":{}}],[\"foreach\",{\"_index\":10,\"name\":{\"11\":{},\"177\":{}},\"comment\":{}}],[\"forkjoin\",{\"_index\":105,\"name\":{\"242\":{},\"367\":{},\"502\":{}},\"comment\":{}}],[\"from\",{\"_index\":8,\"name\":{\"9\":{},\"174\":{},\"410\":{},\"486\":{}},\"comment\":{}}],[\"fromdomstream\",{\"_index\":118,\"name\":{\"368\":{},\"385\":{},\"503\":{}},\"comment\":{}}],[\"fromevent\",{\"_index\":120,\"name\":{\"370\":{},\"505\":{}},\"comment\":{}}],[\"fromeventpattern\",{\"_index\":119,\"name\":{\"369\":{},\"504\":{}},\"comment\":{}}],[\"fromnodestream\",{\"_index\":121,\"name\":{\"371\":{},\"388\":{}},\"comment\":{}}],[\"generate\",{\"_index\":91,\"name\":{\"164\":{},\"373\":{},\"404\":{},\"506\":{}},\"comment\":{}}],[\"generatetime\",{\"_index\":122,\"name\":{\"372\":{},\"507\":{}},\"comment\":{}}],[\"groupby\",{\"_index\":40,\"name\":{\"64\":{},\"244\":{},\"448\":{},\"561\":{}},\"comment\":{}}],[\"groupjoin\",{\"_index\":41,\"name\":{\"66\":{},\"246\":{},\"449\":{},\"562\":{}},\"comment\":{}}],[\"ignoreelements\",{\"_index\":42,\"name\":{\"68\":{},\"248\":{},\"450\":{},\"563\":{}},\"comment\":{}}],[\"iif\",{\"_index\":92,\"name\":{\"165\":{},\"374\":{},\"405\":{},\"508\":{}},\"comment\":{}}],[\"includes\",{\"_index\":43,\"name\":{\"70\":{},\"250\":{},\"406\":{},\"509\":{}},\"comment\":{}}],[\"innerjoin\",{\"_index\":44,\"name\":{\"72\":{},\"252\":{},\"451\":{},\"564\":{}},\"comment\":{}}],[\"intersect\",{\"_index\":45,\"name\":{\"74\":{},\"254\":{},\"452\":{},\"565\":{}},\"comment\":{}}],[\"interval\",{\"_index\":132,\"name\":{\"510\":{}},\"comment\":{}}],[\"isempty\",{\"_index\":46,\"name\":{\"76\":{},\"256\":{},\"407\":{},\"511\":{}},\"comment\":{}}],[\"iterable\",{\"_index\":3,\"name\":{\"3\":{},\"7\":{},\"157\":{},\"386\":{},\"389\":{}},\"comment\":{}}],[\"iterable/operators\",{\"_index\":4,\"name\":{\"4\":{}},\"comment\":{}}],[\"iterablex\",{\"_index\":125,\"name\":{\"408\":{}},\"comment\":{}}],[\"iterator\",{\"_index\":86,\"name\":{\"156\":{}},\"comment\":{}}],[\"ix\",{\"_index\":0,\"name\":{\"0\":{}},\"comment\":{}}],[\"last\",{\"_index\":47,\"name\":{\"78\":{},\"258\":{},\"411\":{},\"512\":{}},\"comment\":{}}],[\"map\",{\"_index\":48,\"name\":{\"80\":{},\"260\":{},\"453\":{},\"566\":{}},\"comment\":{}}],[\"max\",{\"_index\":50,\"name\":{\"84\":{},\"264\":{},\"412\":{},\"513\":{}},\"comment\":{}}],[\"maxby\",{\"_index\":49,\"name\":{\"82\":{},\"262\":{},\"413\":{},\"514\":{}},\"comment\":{}}],[\"memoize\",{\"_index\":51,\"name\":{\"86\":{},\"266\":{},\"454\":{},\"567\":{}},\"comment\":{}}],[\"merge\",{\"_index\":107,\"name\":{\"270\":{},\"375\":{},\"515\":{}},\"comment\":{}}],[\"mergeall\",{\"_index\":106,\"name\":{\"268\":{},\"568\":{}},\"comment\":{}}],[\"mergewith\",{\"_index\":135,\"name\":{\"570\":{}},\"comment\":{}}],[\"min\",{\"_index\":53,\"name\":{\"90\":{},\"274\":{},\"414\":{},\"516\":{}},\"comment\":{}}],[\"minby\",{\"_index\":52,\"name\":{\"88\":{},\"272\":{},\"415\":{},\"517\":{}},\"comment\":{}}],[\"never\",{\"_index\":123,\"name\":{\"376\":{},\"518\":{}},\"comment\":{}}],[\"node\",{\"_index\":2,\"name\":{\"2\":{}},\"comment\":{}}],[\"of\",{\"_index\":93,\"name\":{\"166\":{},\"377\":{},\"416\":{},\"519\":{}},\"comment\":{}}],[\"onerrorresumenext\",{\"_index\":54,\"name\":{\"92\":{},\"167\":{},\"276\":{},\"378\":{},\"417\":{},\"520\":{}},\"comment\":{}}],[\"orderby\",{\"_index\":55,\"name\":{\"94\":{},\"278\":{},\"455\":{},\"571\":{}},\"comment\":{}}],[\"orderbydescending\",{\"_index\":56,\"name\":{\"96\":{},\"280\":{},\"456\":{},\"572\":{}},\"comment\":{}}],[\"pairwise\",{\"_index\":57,\"name\":{\"98\":{},\"282\":{},\"459\":{},\"575\":{}},\"comment\":{}}],[\"pipe\",{\"_index\":11,\"name\":{\"12\":{},\"178\":{}},\"comment\":{}}],[\"pipethrough\",{\"_index\":16,\"name\":{\"17\":{},\"183\":{}},\"comment\":{}}],[\"pipeto\",{\"_index\":15,\"name\":{\"16\":{},\"182\":{}},\"comment\":{}}],[\"pluck\",{\"_index\":58,\"name\":{\"100\":{},\"284\":{},\"460\":{},\"576\":{}},\"comment\":{}}],[\"publish\",{\"_index\":59,\"name\":{\"102\":{},\"286\":{},\"461\":{},\"577\":{}},\"comment\":{}}],[\"race\",{\"_index\":124,\"name\":{\"379\":{},\"521\":{}},\"comment\":{}}],[\"racewith\",{\"_index\":136,\"name\":{\"578\":{}},\"comment\":{}}],[\"range\",{\"_index\":94,\"name\":{\"168\":{},\"380\":{},\"418\":{},\"522\":{}},\"comment\":{}}],[\"reduce\",{\"_index\":61,\"name\":{\"106\":{},\"294\":{},\"420\":{},\"524\":{}},\"comment\":{}}],[\"reduceright\",{\"_index\":60,\"name\":{\"104\":{},\"292\":{},\"419\":{},\"523\":{}},\"comment\":{}}],[\"repeat\",{\"_index\":62,\"name\":{\"108\":{},\"296\":{},\"462\":{},\"579\":{}},\"comment\":{}}],[\"repeatvalue\",{\"_index\":95,\"name\":{\"169\":{},\"381\":{},\"421\":{},\"525\":{}},\"comment\":{}}],[\"retry\",{\"_index\":63,\"name\":{\"110\":{},\"298\":{},\"463\":{},\"580\":{}},\"comment\":{}}],[\"reverse\",{\"_index\":64,\"name\":{\"112\":{},\"300\":{},\"464\":{},\"581\":{}},\"comment\":{}}],[\"scan\",{\"_index\":66,\"name\":{\"116\":{},\"304\":{},\"466\":{},\"583\":{}},\"comment\":{}}],[\"scanright\",{\"_index\":65,\"name\":{\"114\":{},\"302\":{},\"465\":{},\"582\":{}},\"comment\":{}}],[\"sequenceequal\",{\"_index\":67,\"name\":{\"118\":{},\"306\":{},\"422\":{},\"526\":{}},\"comment\":{}}],[\"share\",{\"_index\":68,\"name\":{\"120\":{},\"308\":{},\"467\":{},\"584\":{}},\"comment\":{}}],[\"single\",{\"_index\":69,\"name\":{\"122\":{},\"310\":{},\"423\":{},\"527\":{}},\"comment\":{}}],[\"skip\",{\"_index\":71,\"name\":{\"126\":{},\"314\":{},\"469\":{},\"586\":{}},\"comment\":{}}],[\"skiplast\",{\"_index\":70,\"name\":{\"124\":{},\"312\":{},\"468\":{},\"585\":{}},\"comment\":{}}],[\"skipuntil\",{\"_index\":110,\"name\":{\"316\":{},\"587\":{}},\"comment\":{}}],[\"skipwhile\",{\"_index\":72,\"name\":{\"128\":{},\"318\":{},\"470\":{},\"588\":{}},\"comment\":{}}],[\"slice\",{\"_index\":73,\"name\":{\"130\":{},\"320\":{},\"471\":{},\"589\":{}},\"comment\":{}}],[\"some\",{\"_index\":74,\"name\":{\"132\":{},\"322\":{},\"424\":{},\"528\":{}},\"comment\":{}}],[\"startwith\",{\"_index\":75,\"name\":{\"134\":{},\"324\":{},\"472\":{},\"590\":{}},\"comment\":{}}],[\"sum\",{\"_index\":76,\"name\":{\"136\":{},\"326\":{},\"425\":{},\"529\":{}},\"comment\":{}}],[\"switchall\",{\"_index\":108,\"name\":{\"288\":{},\"592\":{}},\"comment\":{}}],[\"switchmap\",{\"_index\":109,\"name\":{\"290\":{},\"594\":{}},\"comment\":{}}],[\"take\",{\"_index\":78,\"name\":{\"140\":{},\"330\":{},\"474\":{},\"596\":{}},\"comment\":{}}],[\"takelast\",{\"_index\":77,\"name\":{\"138\":{},\"328\":{},\"473\":{},\"595\":{}},\"comment\":{}}],[\"takeuntil\",{\"_index\":111,\"name\":{\"332\":{},\"597\":{}},\"comment\":{}}],[\"takewhile\",{\"_index\":79,\"name\":{\"142\":{},\"334\":{},\"475\":{},\"598\":{}},\"comment\":{}}],[\"tap\",{\"_index\":80,\"name\":{\"144\":{},\"336\":{},\"476\":{},\"599\":{}},\"comment\":{}}],[\"tee\",{\"_index\":14,\"name\":{\"15\":{},\"181\":{}},\"comment\":{}}],[\"thenby\",{\"_index\":127,\"name\":{\"457\":{},\"573\":{}},\"comment\":{}}],[\"thenbydescending\",{\"_index\":128,\"name\":{\"458\":{},\"574\":{}},\"comment\":{}}],[\"throttle\",{\"_index\":112,\"name\":{\"338\":{},\"600\":{}},\"comment\":{}}],[\"throwerror\",{\"_index\":96,\"name\":{\"170\":{},\"382\":{},\"426\":{},\"530\":{}},\"comment\":{}}],[\"timeinterval\",{\"_index\":137,\"name\":{\"601\":{}},\"comment\":{}}],[\"timeout\",{\"_index\":138,\"name\":{\"602\":{}},\"comment\":{}}],[\"timestamp\",{\"_index\":139,\"name\":{\"603\":{}},\"comment\":{}}],[\"toarray\",{\"_index\":81,\"name\":{\"146\":{},\"340\":{},\"427\":{},\"531\":{}},\"comment\":{}}],[\"todomstream\",{\"_index\":12,\"name\":{\"13\":{},\"179\":{},\"428\":{},\"477\":{},\"532\":{},\"604\":{}},\"comment\":{}}],[\"tomap\",{\"_index\":82,\"name\":{\"148\":{},\"342\":{},\"429\":{},\"533\":{}},\"comment\":{}}],[\"tonodestream\",{\"_index\":17,\"name\":{\"18\":{},\"184\":{}},\"comment\":{}}],[\"toobservable\",{\"_index\":113,\"name\":{\"344\":{},\"534\":{}},\"comment\":{}}],[\"toset\",{\"_index\":83,\"name\":{\"150\":{},\"346\":{},\"430\":{},\"535\":{}},\"comment\":{}}],[\"union\",{\"_index\":84,\"name\":{\"152\":{},\"348\":{},\"478\":{},\"605\":{}},\"comment\":{}}],[\"whiledo\",{\"_index\":97,\"name\":{\"171\":{},\"383\":{},\"431\":{},\"536\":{}},\"comment\":{}}],[\"withabort\",{\"_index\":140,\"name\":{\"606\":{}},\"comment\":{}}],[\"withlatestfrom\",{\"_index\":114,\"name\":{\"350\":{},\"608\":{}},\"comment\":{}}],[\"wrapwithabort\",{\"_index\":141,\"name\":{\"607\":{}},\"comment\":{}}],[\"zip\",{\"_index\":85,\"name\":{\"154\":{},\"172\":{},\"352\":{},\"384\":{},\"432\":{},\"537\":{}},\"comment\":{}}],[\"zipwith\",{\"_index\":129,\"name\":{\"479\":{},\"609\":{}},\"comment\":{}}]],\"pipeline\":[]}}"); \ No newline at end of file diff --git a/docs/assets/style.css b/docs/assets/style.css index 07a385b7..18b4f8fe 100644 --- a/docs/assets/style.css +++ b/docs/assets/style.css @@ -11,7 +11,6 @@ --light-color-text-aside: #6e6e6e; --light-color-link: #1f70c2; - --light-color-ts-keyword: #056bd6; --light-color-ts-project: #b111c9; --light-color-ts-module: var(--light-color-ts-project); --light-color-ts-namespace: var(--light-color-ts-project); @@ -33,6 +32,7 @@ --light-color-ts-accessor: var(--light-color-ts-property); --light-color-ts-get-signature: var(--light-color-ts-accessor); --light-color-ts-set-signature: var(--light-color-ts-accessor); + /* object literal not included as it is not used and will be removed in 0.25 */ --light-color-ts-type-alias: #d51270; /* reference not included as links will be colored with the kind that it points to */ @@ -51,7 +51,6 @@ --dark-color-text-aside: #dddddd; --dark-color-link: #00aff4; - --dark-color-ts-keyword: #3399ff; --dark-color-ts-project: #e358ff; --dark-color-ts-module: var(--dark-color-ts-project); --dark-color-ts-namespace: var(--dark-color-ts-project); @@ -73,6 +72,7 @@ --dark-color-ts-accessor: var(--dark-color-ts-property); --dark-color-ts-get-signature: var(--dark-color-ts-accessor); --dark-color-ts-set-signature: var(--dark-color-ts-accessor); + /* object literal not included as it is not used and will be removed in 0.25 */ --dark-color-ts-type-alias: #ff6492; /* reference not included as links will be colored with the kind that it points to */ @@ -93,7 +93,6 @@ --color-text-aside: var(--light-color-text-aside); --color-link: var(--light-color-link); - --color-ts-keyword: var(--light-color-ts-keyword); --color-ts-module: var(--light-color-ts-module); --color-ts-namespace: var(--light-color-ts-namespace); --color-ts-enum: var(--light-color-ts-enum); @@ -135,7 +134,6 @@ --color-text-aside: var(--dark-color-text-aside); --color-link: var(--dark-color-link); - --color-ts-keyword: var(--dark-color-ts-keyword); --color-ts-module: var(--dark-color-ts-module); --color-ts-namespace: var(--dark-color-ts-namespace); --color-ts-enum: var(--dark-color-ts-enum); @@ -184,7 +182,6 @@ body { --color-text-aside: var(--light-color-text-aside); --color-link: var(--light-color-link); - --color-ts-keyword: var(--light-color-ts-keyword); --color-ts-module: var(--light-color-ts-module); --color-ts-namespace: var(--light-color-ts-namespace); --color-ts-enum: var(--light-color-ts-enum); @@ -224,7 +221,6 @@ body { --color-text-aside: var(--dark-color-text-aside); --color-link: var(--dark-color-link); - --color-ts-keyword: var(--dark-color-ts-keyword); --color-ts-module: var(--dark-color-ts-module); --color-ts-namespace: var(--dark-color-ts-namespace); --color-ts-enum: var(--dark-color-ts-enum); @@ -472,12 +468,13 @@ blockquote { padding: 0 0 0 20px; margin: 0; } +.tsd-typography h4, .tsd-typography .tsd-index-panel h3, .tsd-index-panel .tsd-typography h3, -.tsd-typography h4, .tsd-typography h5, .tsd-typography h6 { font-size: 1em; + margin: 0; } .tsd-typography h5, .tsd-typography h6 { @@ -488,19 +485,6 @@ blockquote { .tsd-typography ol { margin: 1em 0; } -.tsd-typography table { - border-collapse: collapse; - border: none; -} -.tsd-typography td, -.tsd-typography th { - padding: 6px 13px; - border: 1px solid var(--color-accent); -} -.tsd-typography thead, -.tsd-typography tr:nth-child(even) { - background-color: var(--color-background-secondary); -} .tsd-breadcrumb { margin: 0; @@ -916,9 +900,8 @@ a.tsd-index-link { box-shadow: 0 0 4px rgba(0, 0, 0, 0.25); } #tsd-search .results li { + padding: 0 10px; background-color: var(--color-background); - line-height: initial; - padding: 4px; } #tsd-search .results li:nth-child(even) { background-color: var(--color-background-secondary); @@ -926,15 +909,12 @@ a.tsd-index-link { #tsd-search .results li.state { display: none; } -#tsd-search .results li.current:not(.no-results), -#tsd-search .results li:hover:not(.no-results) { +#tsd-search .results li.current, +#tsd-search .results li:hover { background-color: var(--color-accent); } #tsd-search .results a { - display: flex; - align-items: center; - padding: 0.25rem; - box-sizing: border-box; + display: block; } #tsd-search .results a:before { top: 10px; @@ -990,11 +970,6 @@ a.tsd-index-link { overflow-x: auto; } -.tsd-signature-keyword { - color: var(--color-ts-keyword); - font-weight: normal; -} - .tsd-signature-symbol { color: var(--color-text-aside); font-weight: normal; @@ -1095,9 +1070,7 @@ ul.tsd-type-parameter-list h5 { overflow: hidden; opacity: 0.8; height: 40px; - transition: - opacity 0.1s, - background-color 0.2s; + transition: opacity 0.1s, background-color 0.2s; vertical-align: bottom; cursor: pointer; } @@ -1149,7 +1122,7 @@ img { } .deprecated { - text-decoration: line-through !important; + text-decoration: line-through; } .warning { diff --git a/docs/classes/Ix.AsyncIterable-1.html b/docs/classes/Ix.AsyncIterable-1.html index aba3ffc2..be274d21 100644 --- a/docs/classes/Ix.AsyncIterable-1.html +++ b/docs/classes/Ix.AsyncIterable-1.html @@ -1,6 +1,167 @@ -AsyncIterable | IxJS

Class AsyncIterable<T>Abstract

This class serves as the base for all operations which support [Symbol.asyncIterator].

-

Type Parameters

  • T

Implements

  • AsyncIterable<T>

Constructors

constructor -

Properties

average +AsyncIterable | ReactiveX IxJS - v6.0.0
+
+ +
+
+
+
+ +

Class AsyncIterable<T>Abstract

+
+

This class serves as the base for all operations which support [Symbol.asyncIterator].

+
+
+
+

Type Parameters

+
    +
  • +

    T

+
+

Hierarchy

+
    +
  • AsyncIterable
+
+

Implements

+
    +
  • AsyncIterable<T>
+
+
+
+ +
+
+

Constructors

+
constructor +
+
+

Properties

+
average batch buffer catchError @@ -86,7 +247,10 @@ union withLatestFrom zip -

Methods

[asyncIterator] +
+
+

Methods

+
[asyncIterator] forEach pipe pipeThrough @@ -94,15 +258,2571 @@ tee as from -

Constructors

constructor

Properties

average

average: {
    (this, options?): Promise<number>;
    <TSource>(this, options?): Promise<number>;
}

Type declaration

    • (this, options?): Promise<number>

    • Parameters

      • this: AsyncIterable<number>
      • Optional options: MathOptions<number>

      Returns Promise<number>

    • <TSource>(this, options?): Promise<number>

    • Type Parameters

      • TSource

      Parameters

      • this: AsyncIterable<TSource>
      • Optional options: MathOptions<TSource>

      Returns Promise<number>

batch

batch: {}

Type declaration

    buffer

    buffer: {}

    Type declaration

      catchError

      catchError: {}

      Type declaration

        combineLatest

        combineLatest: {
            <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>;
            <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>;
            <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>;
            <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>;
            <T>(this, ...sources): AsyncIterable<T[]>;
        }

        Type declaration

          • <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>

          • Type Parameters

            • T

            • T2

            • T3

            Parameters

            • this: AsyncIterable<T>
            • source2: AsyncIterable<T2>
            • source3: AsyncIterable<T3>

            Returns AsyncIterable<[T, T2, T3]>

          • <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>

          • Type Parameters

            • T

            • T2

            • T3

            • T4

            Parameters

            • this: AsyncIterable<T>
            • source2: AsyncIterable<T2>
            • source3: AsyncIterable<T3>
            • source4: AsyncIterable<T4>

            Returns AsyncIterable<[T, T2, T3, T4]>

          • <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>

          • Type Parameters

            • T

            • T2

            • T3

            • T4

            • T5

            Parameters

            • this: AsyncIterable<T>
            • source2: AsyncIterable<T2>
            • source3: AsyncIterable<T3>
            • source4: AsyncIterable<T4>
            • source5: AsyncIterable<T5>

            Returns AsyncIterable<[T, T2, T3, T4, T5]>

          • <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>

          • Type Parameters

            • T

            • T2

            • T3

            • T4

            • T5

            • T6

            Parameters

            • this: AsyncIterable<T>
            • source2: AsyncIterable<T2>
            • source3: AsyncIterable<T3>
            • source4: AsyncIterable<T4>
            • source5: AsyncIterable<T5>
            • source6: AsyncIterable<T6>

            Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>

          • <T>(this, ...sources): AsyncIterable<T[]>

          • Type Parameters

            • T

            Parameters

            Returns AsyncIterable<T[]>

        concat

        concat: {}

        Type declaration

          concatAll

          concatAll: {}

          Type declaration

            concatMap

            concatMap: {}

            Type declaration

              count

              count: {}

              Type declaration

                debounce

                debounce: {}

                Type declaration

                  defaultIfEmpty

                  defaultIfEmpty: {}

                  Type declaration

                    delay

                    delay: (<TSource>(this, dueTime) => AsyncIterable<TSource>)

                    Type declaration

                    delayEach

                    delayEach: (<TSource>(this, dueTime) => AsyncIterable<TSource>)

                    Type declaration

                    distinct

                    distinct: {}

                    Type declaration

                      distinctUntilChanged

                      distinctUntilChanged: {}

                      Type declaration

                        doWhile

                        doWhile: {}

                        Type declaration

                          elementAt

                          elementAt: {}

                          Type declaration

                            endWith

                            endWith: {}

                            Type declaration

                              every

                              every: {}

                              Type declaration

                                except

                                except: {}

                                Type declaration

                                  expand

                                  expand: {}

                                  Type declaration

                                    filter

                                    filter: (<T>(this, predicate, thisArg?) => AsyncIterable<T>)

                                    Type declaration

                                      • <T>(this, predicate, thisArg?): AsyncIterable<T>

                                      • Type Parameters

                                        • T

                                        Parameters

                                        • this: AsyncIterable<T>
                                        • predicate: ((value, index, signal?) => boolean | Promise<boolean>)
                                            • (value, index, signal?): boolean | Promise<boolean>

                                            • Parameters

                                              • value: T
                                              • index: number
                                              • Optional signal: AbortSignal

                                              Returns boolean | Promise<boolean>

                                        • Optional thisArg: any

                                        Returns AsyncIterable<T>

                                    finalize

                                    finalize: {}

                                    Type declaration

                                      find

                                      find: {}

                                      Type declaration

                                        findIndex

                                        findIndex: {}

                                        Type declaration

                                          first

                                          first: {}

                                          Type declaration

                                            flat

                                            flat: {}

                                            Type declaration

                                              flatMap

                                              flatMap: {}

                                              Type declaration

                                                forkJoin

                                                forkJoin: {
                                                    <T, T2, T3>(this, source2, source3): Promise<[T, T2, T3] | undefined>;
                                                    <T, T2, T3, T4>(this, source2, source3, source4): Promise<[T, T2, T3, T4] | undefined>;
                                                    <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): Promise<[T, T2, T3, T4, T5] | undefined>;
                                                    <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): Promise<[T, T2, T3, T4, T5, T6] | undefined>;
                                                    <T>(this, ...sources): Promise<T[] | undefined>;
                                                }

                                                Type declaration

                                                  • <T, T2, T3>(this, source2, source3): Promise<[T, T2, T3] | undefined>

                                                  • Type Parameters

                                                    • T

                                                    • T2

                                                    • T3

                                                    Parameters

                                                    • this: AsyncIterable<T>
                                                    • source2: AsyncIterable<T2>
                                                    • source3: AsyncIterable<T3>

                                                    Returns Promise<[T, T2, T3] | undefined>

                                                  • <T, T2, T3, T4>(this, source2, source3, source4): Promise<[T, T2, T3, T4] | undefined>

                                                  • Type Parameters

                                                    • T

                                                    • T2

                                                    • T3

                                                    • T4

                                                    Parameters

                                                    • this: AsyncIterable<T>
                                                    • source2: AsyncIterable<T2>
                                                    • source3: AsyncIterable<T3>
                                                    • source4: AsyncIterable<T4>

                                                    Returns Promise<[T, T2, T3, T4] | undefined>

                                                  • <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): Promise<[T, T2, T3, T4, T5] | undefined>

                                                  • Type Parameters

                                                    • T

                                                    • T2

                                                    • T3

                                                    • T4

                                                    • T5

                                                    Parameters

                                                    • this: AsyncIterable<T>
                                                    • source2: AsyncIterable<T2>
                                                    • source3: AsyncIterable<T3>
                                                    • source4: AsyncIterable<T4>
                                                    • source5: AsyncIterable<T5>

                                                    Returns Promise<[T, T2, T3, T4, T5] | undefined>

                                                  • <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): Promise<[T, T2, T3, T4, T5, T6] | undefined>

                                                  • Type Parameters

                                                    • T

                                                    • T2

                                                    • T3

                                                    • T4

                                                    • T5

                                                    • T6

                                                    Parameters

                                                    • this: AsyncIterable<T>
                                                    • source2: AsyncIterable<T2>
                                                    • source3: AsyncIterable<T3>
                                                    • source4: AsyncIterable<T4>
                                                    • source5: AsyncIterable<T5>
                                                    • source6: AsyncIterable<T6>

                                                    Returns Promise<[T, T2, T3, T4, T5, T6] | undefined>

                                                  • <T>(this, ...sources): Promise<T[] | undefined>

                                                  • Type Parameters

                                                    • T

                                                    Parameters

                                                    Returns Promise<T[] | undefined>

                                                groupBy

                                                groupBy: {
                                                    <TSource, TKey>(this, keySelector): AsyncIterable<GroupedAsyncIterable<TKey, TSource>>;
                                                    <TSource, TKey, TValue>(this, keySelector, elementSelector?): AsyncIterable<GroupedAsyncIterable<TKey, TValue>>;
                                                }

                                                Type declaration

                                                  • <TSource, TKey>(this, keySelector): AsyncIterable<GroupedAsyncIterable<TKey, TSource>>

                                                  • Type Parameters

                                                    • TSource

                                                    • TKey

                                                    Parameters

                                                    • this: AsyncIterable<TSource>
                                                    • keySelector: ((value, signal?) => TKey | Promise<TKey>)
                                                        • (value, signal?): TKey | Promise<TKey>

                                                        • Parameters

                                                          • value: TSource
                                                          • Optional signal: AbortSignal

                                                          Returns TKey | Promise<TKey>

                                                    Returns AsyncIterable<GroupedAsyncIterable<TKey, TSource>>

                                                  • <TSource, TKey, TValue>(this, keySelector, elementSelector?): AsyncIterable<GroupedAsyncIterable<TKey, TValue>>

                                                  • Type Parameters

                                                    • TSource

                                                    • TKey

                                                    • TValue

                                                    Parameters

                                                    • this: AsyncIterable<TSource>
                                                    • keySelector: ((value, signal?) => TKey | Promise<TKey>)
                                                        • (value, signal?): TKey | Promise<TKey>

                                                        • Parameters

                                                          • value: TSource
                                                          • Optional signal: AbortSignal

                                                          Returns TKey | Promise<TKey>

                                                    • Optional elementSelector: ((value, signal?) => TValue | Promise<TValue>)
                                                        • (value, signal?): TValue | Promise<TValue>

                                                        • Parameters

                                                          • value: TSource
                                                          • Optional signal: AbortSignal

                                                          Returns TValue | Promise<TValue>

                                                    Returns AsyncIterable<GroupedAsyncIterable<TKey, TValue>>

                                                groupJoin

                                                groupJoin: {}

                                                Type declaration

                                                  ignoreElements

                                                  ignoreElements: {}

                                                  Type declaration

                                                    includes

                                                    includes: {}

                                                    Type declaration

                                                      innerJoin

                                                      innerJoin: {}

                                                      Type declaration

                                                        intersect

                                                        intersect: {}

                                                        Type declaration

                                                          isEmpty

                                                          isEmpty: {}

                                                          Type declaration

                                                            last

                                                            last: {}

                                                            Type declaration

                                                              map

                                                              map: {}

                                                              Type declaration

                                                                max

                                                                max: (<TSource, TResult>(this, options?) => Promise<TResult>)

                                                                Type declaration

                                                                  • <TSource, TResult>(this, options?): Promise<TResult>

                                                                  • Type Parameters

                                                                    • TSource

                                                                    • TResult = TSource

                                                                    Parameters

                                                                    • this: AsyncIterable<TSource>
                                                                    • Optional options: ExtremaOptions<TSource, TResult>

                                                                    Returns Promise<TResult>

                                                                maxBy

                                                                maxBy: {}

                                                                Type declaration

                                                                  memoize

                                                                  memoize: {
                                                                      <T>(this, readerCount?): AsyncIterable<T>;
                                                                      <T, R>(this, readerCount?, selector?): AsyncIterable<R>;
                                                                  }

                                                                  Type declaration

                                                                    • <T>(this, readerCount?): AsyncIterable<T>

                                                                    • Type Parameters

                                                                      • T

                                                                      Parameters

                                                                      Returns AsyncIterable<T>

                                                                    • <T, R>(this, readerCount?, selector?): AsyncIterable<R>

                                                                    • Type Parameters

                                                                      • T

                                                                      • R

                                                                      Parameters

                                                                      • this: AsyncIterable<T>
                                                                      • Optional readerCount: number
                                                                      • Optional selector: ((value, signal?) => AsyncIterable<R>)
                                                                          • (value, signal?): AsyncIterable<R>

                                                                          • Parameters

                                                                            • value: AsyncIterable<T>
                                                                            • Optional signal: AbortSignal

                                                                            Returns AsyncIterable<R>

                                                                      Returns AsyncIterable<R>

                                                                  merge

                                                                  merge: {}

                                                                  Type declaration

                                                                    mergeAll

                                                                    mergeAll: {}

                                                                    Type declaration

                                                                      min

                                                                      min: (<TSource, TResult>(this, options?) => Promise<TResult>)

                                                                      Type declaration

                                                                        • <TSource, TResult>(this, options?): Promise<TResult>

                                                                        • Type Parameters

                                                                          • TSource

                                                                          • TResult = TSource

                                                                          Parameters

                                                                          • this: AsyncIterable<TSource>
                                                                          • Optional options: ExtremaOptions<TSource, TResult>

                                                                          Returns Promise<TResult>

                                                                      minBy

                                                                      minBy: {}

                                                                      Type declaration

                                                                        onErrorResumeNext

                                                                        onErrorResumeNext: {}

                                                                        Type declaration

                                                                          orderBy

                                                                          orderBy: {}

                                                                          Type declaration

                                                                            orderByDescending

                                                                            orderByDescending: {}

                                                                            Type declaration

                                                                              pairwise

                                                                              pairwise: {}

                                                                              Type declaration

                                                                                pluck

                                                                                pluck: {}

                                                                                Type declaration

                                                                                  publish

                                                                                  publish: {
                                                                                      <TSource>(this): AsyncIterable<TSource>;
                                                                                      <TSource, TResult>(this, selector?): AsyncIterable<TResult>;
                                                                                  }

                                                                                  Type declaration

                                                                                    • <TSource>(this): AsyncIterable<TSource>

                                                                                    • Type Parameters

                                                                                      • TSource

                                                                                      Parameters

                                                                                      Returns AsyncIterable<TSource>

                                                                                    • <TSource, TResult>(this, selector?): AsyncIterable<TResult>

                                                                                    • Type Parameters

                                                                                      • TSource

                                                                                      • TResult

                                                                                      Parameters

                                                                                      • this: AsyncIterable<TSource>
                                                                                      • Optional selector: ((value) => AsyncIterable<TResult>)
                                                                                          • (value): AsyncIterable<TResult>

                                                                                          • Parameters

                                                                                            • value: AsyncIterable<TSource>

                                                                                            Returns AsyncIterable<TResult>

                                                                                      Returns AsyncIterable<TResult>

                                                                                  reduce

                                                                                  reduce: {}

                                                                                  Type declaration

                                                                                    reduceRight

                                                                                    reduceRight: {}

                                                                                    Type declaration

                                                                                      repeat

                                                                                      repeat: {}

                                                                                      Type declaration

                                                                                        retry

                                                                                        retry: {}

                                                                                        Type declaration

                                                                                          reverse

                                                                                          reverse: {}

                                                                                          Type declaration

                                                                                            scan

                                                                                            scan: {}

                                                                                            Type declaration

                                                                                              scanRight

                                                                                              scanRight: {}

                                                                                              Type declaration

                                                                                                sequenceEqual

                                                                                                sequenceEqual: {}

                                                                                                Type declaration

                                                                                                  share

                                                                                                  share: {
                                                                                                      <TSource>(this): AsyncIterable<TSource>;
                                                                                                      <TSource, TResult>(this, selector?): AsyncIterable<TResult>;
                                                                                                  }

                                                                                                  Type declaration

                                                                                                    • <TSource>(this): AsyncIterable<TSource>

                                                                                                    • Type Parameters

                                                                                                      • TSource

                                                                                                      Parameters

                                                                                                      Returns AsyncIterable<TSource>

                                                                                                    • <TSource, TResult>(this, selector?): AsyncIterable<TResult>

                                                                                                    • Type Parameters

                                                                                                      • TSource

                                                                                                      • TResult

                                                                                                      Parameters

                                                                                                      • this: AsyncIterable<TSource>
                                                                                                      • Optional selector: ((value) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>)
                                                                                                          • (value): AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>

                                                                                                          • Parameters

                                                                                                            • value: AsyncIterable<TSource>

                                                                                                            Returns AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>

                                                                                                      Returns AsyncIterable<TResult>

                                                                                                  single

                                                                                                  single: {}

                                                                                                  Type declaration

                                                                                                    skip

                                                                                                    skip: {}

                                                                                                    Type declaration

                                                                                                      skipLast

                                                                                                      skipLast: {}

                                                                                                      Type declaration

                                                                                                        skipUntil

                                                                                                        skipUntil: {}

                                                                                                        Type declaration

                                                                                                          skipWhile

                                                                                                          skipWhile: (<T>(this, predicate) => AsyncIterable<T>)

                                                                                                          Type declaration

                                                                                                            • <T>(this, predicate): AsyncIterable<T>

                                                                                                            • Type Parameters

                                                                                                              • T

                                                                                                              Parameters

                                                                                                              • this: AsyncIterable<T>
                                                                                                              • predicate: ((value, index, signal?) => boolean | Promise<boolean>)
                                                                                                                  • (value, index, signal?): boolean | Promise<boolean>

                                                                                                                  • Parameters

                                                                                                                    • value: T
                                                                                                                    • index: number
                                                                                                                    • Optional signal: AbortSignal

                                                                                                                    Returns boolean | Promise<boolean>

                                                                                                              Returns AsyncIterable<T>

                                                                                                          slice

                                                                                                          slice: {}

                                                                                                          Type declaration

                                                                                                            some

                                                                                                            some: {}

                                                                                                            Type declaration

                                                                                                              startWith

                                                                                                              startWith: {}

                                                                                                              Type declaration

                                                                                                                sum

                                                                                                                sum: {
                                                                                                                    (this, options?): Promise<number>;
                                                                                                                    <T>(this, options?): Promise<number>;
                                                                                                                }

                                                                                                                Type declaration

                                                                                                                  • (this, options?): Promise<number>

                                                                                                                  • Parameters

                                                                                                                    • this: AsyncIterable<number>
                                                                                                                    • Optional options: MathOptions<number>

                                                                                                                    Returns Promise<number>

                                                                                                                  • <T>(this, options?): Promise<number>

                                                                                                                  • Type Parameters

                                                                                                                    • T

                                                                                                                    Parameters

                                                                                                                    • this: AsyncIterable<T>
                                                                                                                    • Optional options: MathOptions<T>

                                                                                                                    Returns Promise<number>

                                                                                                                switchAll

                                                                                                                switchAll: {}

                                                                                                                Type declaration

                                                                                                                  switchMap

                                                                                                                  switchMap: {}

                                                                                                                  Type declaration

                                                                                                                    take

                                                                                                                    take: {}

                                                                                                                    Type declaration

                                                                                                                      takeLast

                                                                                                                      takeLast: {}

                                                                                                                      Type declaration

                                                                                                                        takeUntil

                                                                                                                        takeUntil: {}

                                                                                                                        Type declaration

                                                                                                                          takeWhile

                                                                                                                          takeWhile: (<T>(this, predicate) => AsyncIterable<T>)

                                                                                                                          Type declaration

                                                                                                                            • <T>(this, predicate): AsyncIterable<T>

                                                                                                                            • Type Parameters

                                                                                                                              • T

                                                                                                                              Parameters

                                                                                                                              • this: AsyncIterable<T>
                                                                                                                              • predicate: ((value, index, signal?) => boolean | Promise<boolean>)
                                                                                                                                  • (value, index, signal?): boolean | Promise<boolean>

                                                                                                                                  • Parameters

                                                                                                                                    • value: T
                                                                                                                                    • index: number
                                                                                                                                    • Optional signal: AbortSignal

                                                                                                                                    Returns boolean | Promise<boolean>

                                                                                                                              Returns AsyncIterable<T>

                                                                                                                          tap

                                                                                                                          tap: {}

                                                                                                                          Type declaration

                                                                                                                            throttle

                                                                                                                            throttle: {}

                                                                                                                            Type declaration

                                                                                                                              toArray

                                                                                                                              toArray: {}

                                                                                                                              Type declaration

                                                                                                                                toDOMStream

                                                                                                                                toDOMStream: {
                                                                                                                                    <T>(this, options): ReadableStream<Uint8Array>;
                                                                                                                                    <T>(this, options): ReadableStream<Uint8Array>;
                                                                                                                                }

                                                                                                                                Type declaration

                                                                                                                                  • <T>(this, options): ReadableStream<Uint8Array>

                                                                                                                                  • Type Parameters

                                                                                                                                    • T

                                                                                                                                    Parameters

                                                                                                                                    • this: AsyncIterable<T>
                                                                                                                                    • options: ReadableBYOBStreamOptions<Uint8Array>

                                                                                                                                    Returns ReadableStream<Uint8Array>

                                                                                                                                  • <T>(this, options): ReadableStream<Uint8Array>

                                                                                                                                  • Type Parameters

                                                                                                                                    • T

                                                                                                                                    Parameters

                                                                                                                                    • this: AsyncIterable<T>
                                                                                                                                    • options: ReadableByteStreamOptions<Uint8Array>

                                                                                                                                    Returns ReadableStream<Uint8Array>

                                                                                                                                toMap

                                                                                                                                toMap: (<TSource, TKey, TElement>(this, options) => Promise<Map<TKey, TElement | TSource>>)

                                                                                                                                Type declaration

                                                                                                                                  • <TSource, TKey, TElement>(this, options): Promise<Map<TKey, TElement | TSource>>

                                                                                                                                  • Type Parameters

                                                                                                                                    • TSource

                                                                                                                                    • TKey

                                                                                                                                    • TElement = TSource

                                                                                                                                    Parameters

                                                                                                                                    • this: AsyncIterable<TSource>
                                                                                                                                    • options: ToMapOptions<TSource, TKey, TElement>

                                                                                                                                    Returns Promise<Map<TKey, TElement | TSource>>

                                                                                                                                toNodeStream

                                                                                                                                toNodeStream: {
                                                                                                                                    <TSource>(this, options): AsyncIterableReadable<TSource>;
                                                                                                                                    <TSource>(this, options): AsyncIterableReadable<TSource>;
                                                                                                                                }

                                                                                                                                Type declaration

                                                                                                                                  • <TSource>(this, options): AsyncIterableReadable<TSource>

                                                                                                                                  • Type Parameters

                                                                                                                                    • TSource

                                                                                                                                    Parameters

                                                                                                                                    • this: AsyncIterable<TSource>
                                                                                                                                    • options: ReadableOptions & {
                                                                                                                                          objectMode: true;
                                                                                                                                      }

                                                                                                                                    Returns AsyncIterableReadable<TSource>

                                                                                                                                  • <TSource>(this, options): AsyncIterableReadable<TSource>

                                                                                                                                  • Type Parameters

                                                                                                                                    • TSource extends BufferLike

                                                                                                                                    Parameters

                                                                                                                                    • this: AsyncIterable<TSource>
                                                                                                                                    • options: ReadableOptions & {
                                                                                                                                          objectMode: false;
                                                                                                                                      }

                                                                                                                                    Returns AsyncIterableReadable<TSource>

                                                                                                                                toObservable

                                                                                                                                toObservable: {}

                                                                                                                                Type declaration

                                                                                                                                  toSet

                                                                                                                                  toSet: {}

                                                                                                                                  Type declaration

                                                                                                                                    union

                                                                                                                                    union: {}

                                                                                                                                    Type declaration

                                                                                                                                      withLatestFrom

                                                                                                                                      withLatestFrom: {
                                                                                                                                          <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>;
                                                                                                                                          <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>;
                                                                                                                                          <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>;
                                                                                                                                          <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>;
                                                                                                                                          <T>(this, ...sources): AsyncIterable<T[]>;
                                                                                                                                      }

                                                                                                                                      Type declaration

                                                                                                                                        • <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>

                                                                                                                                        • Type Parameters

                                                                                                                                          • T

                                                                                                                                          • T2

                                                                                                                                          • T3

                                                                                                                                          Parameters

                                                                                                                                          • this: AsyncIterable<T>
                                                                                                                                          • source2: AsyncIterable<T2>
                                                                                                                                          • source3: AsyncIterable<T3>

                                                                                                                                          Returns AsyncIterable<[T, T2, T3]>

                                                                                                                                        • <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                        • Type Parameters

                                                                                                                                          • T

                                                                                                                                          • T2

                                                                                                                                          • T3

                                                                                                                                          • T4

                                                                                                                                          Parameters

                                                                                                                                          • this: AsyncIterable<T>
                                                                                                                                          • source2: AsyncIterable<T2>
                                                                                                                                          • source3: AsyncIterable<T3>
                                                                                                                                          • source4: AsyncIterable<T4>

                                                                                                                                          Returns AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                        • <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                        • Type Parameters

                                                                                                                                          • T

                                                                                                                                          • T2

                                                                                                                                          • T3

                                                                                                                                          • T4

                                                                                                                                          • T5

                                                                                                                                          Parameters

                                                                                                                                          • this: AsyncIterable<T>
                                                                                                                                          • source2: AsyncIterable<T2>
                                                                                                                                          • source3: AsyncIterable<T3>
                                                                                                                                          • source4: AsyncIterable<T4>
                                                                                                                                          • source5: AsyncIterable<T5>

                                                                                                                                          Returns AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                        • <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                        • Type Parameters

                                                                                                                                          • T

                                                                                                                                          • T2

                                                                                                                                          • T3

                                                                                                                                          • T4

                                                                                                                                          • T5

                                                                                                                                          • T6

                                                                                                                                          Parameters

                                                                                                                                          • this: AsyncIterable<T>
                                                                                                                                          • source2: AsyncIterable<T2>
                                                                                                                                          • source3: AsyncIterable<T3>
                                                                                                                                          • source4: AsyncIterable<T4>
                                                                                                                                          • source5: AsyncIterable<T5>
                                                                                                                                          • source6: AsyncIterable<T6>

                                                                                                                                          Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                        • <T>(this, ...sources): AsyncIterable<T[]>

                                                                                                                                        • Type Parameters

                                                                                                                                          • T

                                                                                                                                          Parameters

                                                                                                                                          Returns AsyncIterable<T[]>

                                                                                                                                      zip

                                                                                                                                      zip: {
                                                                                                                                          <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>;
                                                                                                                                          <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>;
                                                                                                                                          <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>;
                                                                                                                                          <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>;
                                                                                                                                          <T>(this, ...sources): AsyncIterable<T[]>;
                                                                                                                                      }

                                                                                                                                      Type declaration

                                                                                                                                        • <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>

                                                                                                                                        • Type Parameters

                                                                                                                                          • T

                                                                                                                                          • T2

                                                                                                                                          • T3

                                                                                                                                          Parameters

                                                                                                                                          • this: AsyncIterable<T>
                                                                                                                                          • source2: AsyncIterable<T2>
                                                                                                                                          • source3: AsyncIterable<T3>

                                                                                                                                          Returns AsyncIterable<[T, T2, T3]>

                                                                                                                                        • <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                        • Type Parameters

                                                                                                                                          • T

                                                                                                                                          • T2

                                                                                                                                          • T3

                                                                                                                                          • T4

                                                                                                                                          Parameters

                                                                                                                                          • this: AsyncIterable<T>
                                                                                                                                          • source2: AsyncIterable<T2>
                                                                                                                                          • source3: AsyncIterable<T3>
                                                                                                                                          • source4: AsyncIterable<T4>

                                                                                                                                          Returns AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                        • <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                        • Type Parameters

                                                                                                                                          • T

                                                                                                                                          • T2

                                                                                                                                          • T3

                                                                                                                                          • T4

                                                                                                                                          • T5

                                                                                                                                          Parameters

                                                                                                                                          • this: AsyncIterable<T>
                                                                                                                                          • source2: AsyncIterable<T2>
                                                                                                                                          • source3: AsyncIterable<T3>
                                                                                                                                          • source4: AsyncIterable<T4>
                                                                                                                                          • source5: AsyncIterable<T5>

                                                                                                                                          Returns AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                        • <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                        • Type Parameters

                                                                                                                                          • T

                                                                                                                                          • T2

                                                                                                                                          • T3

                                                                                                                                          • T4

                                                                                                                                          • T5

                                                                                                                                          • T6

                                                                                                                                          Parameters

                                                                                                                                          • this: AsyncIterable<T>
                                                                                                                                          • source2: AsyncIterable<T2>
                                                                                                                                          • source3: AsyncIterable<T3>
                                                                                                                                          • source4: AsyncIterable<T4>
                                                                                                                                          • source5: AsyncIterable<T5>
                                                                                                                                          • source6: AsyncIterable<T6>

                                                                                                                                          Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                        • <T>(this, ...sources): AsyncIterable<T[]>

                                                                                                                                        • Type Parameters

                                                                                                                                          • T

                                                                                                                                          Parameters

                                                                                                                                          Returns AsyncIterable<T[]>

                                                                                                                                      Methods

                                                                                                                                      Abstract [asyncIterator]

                                                                                                                                      • [asyncIterator](signal?): AsyncIterator<T, any, undefined>

                                                                                                                                      • Parameters

                                                                                                                                        • Optional signal: AbortSignal

                                                                                                                                        Returns AsyncIterator<T, any, undefined>

                                                                                                                                      forEach

                                                                                                                                      • forEach(projection, thisArg?, signal?): Promise<void>

                                                                                                                                      • Parameters

                                                                                                                                        • projection: ((value, index, signal?) => void | Promise<void>)
                                                                                                                                            • (value, index, signal?): void | Promise<void>

                                                                                                                                            • Parameters

                                                                                                                                              • value: T
                                                                                                                                              • index: number
                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                              Returns void | Promise<void>

                                                                                                                                        • Optional thisArg: any
                                                                                                                                        • Optional signal: AbortSignal

                                                                                                                                        Returns Promise<void>

                                                                                                                                        Nocollapse

                                                                                                                                      pipe

                                                                                                                                      pipeThrough

                                                                                                                                      • pipeThrough<R>(duplex, options?): R

                                                                                                                                      • Type Parameters

                                                                                                                                        • R extends ReadableStream<any>

                                                                                                                                        Parameters

                                                                                                                                        • duplex: {
                                                                                                                                              readable: R;
                                                                                                                                              writable: WritableStream<T>;
                                                                                                                                          }
                                                                                                                                          • readable: R
                                                                                                                                          • writable: WritableStream<T>
                                                                                                                                        • Optional options: StreamPipeOptions

                                                                                                                                        Returns R

                                                                                                                                      pipeTo

                                                                                                                                      • pipeTo(writable, options?): Promise<void>

                                                                                                                                      • Parameters

                                                                                                                                        • writable: WritableStream<T>
                                                                                                                                        • Optional options: StreamPipeOptions

                                                                                                                                        Returns Promise<void>

                                                                                                                                      tee

                                                                                                                                      Static as

                                                                                                                                      • as(source): AsyncIterable<string>

                                                                                                                                      • Converts an existing string into an async-iterable of characters.

                                                                                                                                        -

                                                                                                                                        Parameters

                                                                                                                                        • source: string

                                                                                                                                          The string to convert to an async-iterable.

                                                                                                                                          -

                                                                                                                                        Returns AsyncIterable<string>

                                                                                                                                        An async-iterable stream of characters from the source.

                                                                                                                                        -
                                                                                                                                      • as<T>(source): AsyncIterable<T>

                                                                                                                                      • Converts the AsyncIterable-like input or single element into an AsyncIterable.

                                                                                                                                        -

                                                                                                                                        Type Parameters

                                                                                                                                        • T

                                                                                                                                          The type of elements in the async-iterable like sequence.

                                                                                                                                          -

                                                                                                                                        Parameters

                                                                                                                                        • source: T | AsyncIterableInput<T>

                                                                                                                                          The async-iterable like input to convert to an async-iterable.

                                                                                                                                          -

                                                                                                                                        Returns AsyncIterable<T>

                                                                                                                                        An async-iterable stream from elements in the async-iterable like sequence.

                                                                                                                                        -
                                                                                                                                      • as<T>(source): AsyncIterable<T>

                                                                                                                                      • Converts the single element into an async-iterable sequence.

                                                                                                                                        -

                                                                                                                                        Type Parameters

                                                                                                                                        • T

                                                                                                                                          The type of the input to turn into an async-iterable sequence.

                                                                                                                                          -

                                                                                                                                        Parameters

                                                                                                                                        • source: T

                                                                                                                                          The single element to turn into an async-iterable sequence.

                                                                                                                                          -

                                                                                                                                        Returns AsyncIterable<T>

                                                                                                                                        An async-iterable sequence which contains the single element.

                                                                                                                                        -

                                                                                                                                      Static from

                                                                                                                                      • from<TSource, TResult>(source, selector?, thisArg?): AsyncIterable<TResult>

                                                                                                                                      • Type Parameters

                                                                                                                                        • TSource

                                                                                                                                        • TResult = TSource

                                                                                                                                        Parameters

                                                                                                                                        • source: AsyncIterableInput<TSource>
                                                                                                                                        • selector: ((value, index) => TResult | Promise<TResult>) = identityAsync
                                                                                                                                            • (value, index): TResult | Promise<TResult>

                                                                                                                                            • Parameters

                                                                                                                                              • value: TSource
                                                                                                                                              • index: number

                                                                                                                                              Returns TResult | Promise<TResult>

                                                                                                                                        • Optional thisArg: any

                                                                                                                                        Returns AsyncIterable<TResult>

                                                                                                                                        Nocollapse

                                                                                                                                      Settings

                                                                                                                                      Member Visibility

                                                                                                                                      Theme

                                                                                                                                      On This Page

                                                                                                                                      \ No newline at end of file +
                                                                                                                                      +
                                                                                                                                      +

                                                                                                                                      Constructors

                                                                                                                                      +
                                                                                                                                      +

                                                                                                                                      constructor

                                                                                                                                      +
                                                                                                                                      +
                                                                                                                                      +

                                                                                                                                      Properties

                                                                                                                                      +
                                                                                                                                      +

                                                                                                                                      average

                                                                                                                                      +
                                                                                                                                      average: {
                                                                                                                                          (this, options?): Promise<number>;
                                                                                                                                          <TSource>(this, options?): Promise<number>;
                                                                                                                                      }
                                                                                                                                      +
                                                                                                                                      +

                                                                                                                                      Type declaration

                                                                                                                                      +
                                                                                                                                        +
                                                                                                                                      • +
                                                                                                                                          +
                                                                                                                                        • (this, options?): Promise<number>
                                                                                                                                          • +
                                                                                                                                        • +
                                                                                                                                          +

                                                                                                                                          Parameters

                                                                                                                                          +
                                                                                                                                            +
                                                                                                                                          • +
                                                                                                                                            this: AsyncIterable<number>
                                                                                                                                            • +
                                                                                                                                          • +
                                                                                                                                            Optional options: MathOptions<number>
                                                                                                                                          +

                                                                                                                                          Returns Promise<number>

                                                                                                                                          • +
                                                                                                                                        • <TSource>(this, options?): Promise<number>
                                                                                                                                          • +
                                                                                                                                        • +
                                                                                                                                          +

                                                                                                                                          Type Parameters

                                                                                                                                          +
                                                                                                                                            +
                                                                                                                                          • +

                                                                                                                                            TSource

                                                                                                                                          +
                                                                                                                                          +

                                                                                                                                          Parameters

                                                                                                                                          +
                                                                                                                                            +
                                                                                                                                          • +
                                                                                                                                            this: AsyncIterable<TSource>
                                                                                                                                            • +
                                                                                                                                          • +
                                                                                                                                            Optional options: MathOptions<TSource>
                                                                                                                                          +

                                                                                                                                          Returns Promise<number>

                                                                                                                                      +
                                                                                                                                      +

                                                                                                                                      batch

                                                                                                                                      +
                                                                                                                                      batch: {}
                                                                                                                                      +
                                                                                                                                      +

                                                                                                                                      Type declaration

                                                                                                                                      +
                                                                                                                                        +
                                                                                                                                      • +
                                                                                                                                        +
                                                                                                                                        +

                                                                                                                                        buffer

                                                                                                                                        +
                                                                                                                                        buffer: {}
                                                                                                                                        +
                                                                                                                                        +

                                                                                                                                        Type declaration

                                                                                                                                        +
                                                                                                                                          +
                                                                                                                                        • +
                                                                                                                                          +
                                                                                                                                          +

                                                                                                                                          catchError

                                                                                                                                          +
                                                                                                                                          catchError: {}
                                                                                                                                          +
                                                                                                                                          +

                                                                                                                                          Type declaration

                                                                                                                                          +
                                                                                                                                            +
                                                                                                                                          • +
                                                                                                                                            +
                                                                                                                                            +

                                                                                                                                            combineLatest

                                                                                                                                            +
                                                                                                                                            combineLatest: {
                                                                                                                                                <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>;
                                                                                                                                                <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>;
                                                                                                                                                <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>;
                                                                                                                                                <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>;
                                                                                                                                                <T>(this, ...sources): AsyncIterable<T[]>;
                                                                                                                                            }
                                                                                                                                            +
                                                                                                                                            +

                                                                                                                                            Type declaration

                                                                                                                                            +
                                                                                                                                              +
                                                                                                                                            • +
                                                                                                                                                +
                                                                                                                                              • <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>
                                                                                                                                                • +
                                                                                                                                              • +
                                                                                                                                                +

                                                                                                                                                Type Parameters

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • +

                                                                                                                                                  T

                                                                                                                                                  • +
                                                                                                                                                • +

                                                                                                                                                  T2

                                                                                                                                                  • +
                                                                                                                                                • +

                                                                                                                                                  T3

                                                                                                                                                +
                                                                                                                                                +

                                                                                                                                                Parameters

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • +
                                                                                                                                                  this: AsyncIterable<T>
                                                                                                                                                  • +
                                                                                                                                                • +
                                                                                                                                                  source2: AsyncIterable<T2>
                                                                                                                                                  • +
                                                                                                                                                • +
                                                                                                                                                  source3: AsyncIterable<T3>
                                                                                                                                                +

                                                                                                                                                Returns AsyncIterable<[T, T2, T3]>

                                                                                                                                                • +
                                                                                                                                              • <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>
                                                                                                                                                • +
                                                                                                                                              • +
                                                                                                                                                +

                                                                                                                                                Type Parameters

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • +

                                                                                                                                                  T

                                                                                                                                                  • +
                                                                                                                                                • +

                                                                                                                                                  T2

                                                                                                                                                  • +
                                                                                                                                                • +

                                                                                                                                                  T3

                                                                                                                                                  • +
                                                                                                                                                • +

                                                                                                                                                  T4

                                                                                                                                                +
                                                                                                                                                +

                                                                                                                                                Parameters

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • +
                                                                                                                                                  this: AsyncIterable<T>
                                                                                                                                                  • +
                                                                                                                                                • +
                                                                                                                                                  source2: AsyncIterable<T2>
                                                                                                                                                  • +
                                                                                                                                                • +
                                                                                                                                                  source3: AsyncIterable<T3>
                                                                                                                                                  • +
                                                                                                                                                • +
                                                                                                                                                  source4: AsyncIterable<T4>
                                                                                                                                                +

                                                                                                                                                Returns AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                                • +
                                                                                                                                              • <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>
                                                                                                                                                • +
                                                                                                                                              • +
                                                                                                                                                +

                                                                                                                                                Type Parameters

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • +

                                                                                                                                                  T

                                                                                                                                                  • +
                                                                                                                                                • +

                                                                                                                                                  T2

                                                                                                                                                  • +
                                                                                                                                                • +

                                                                                                                                                  T3

                                                                                                                                                  • +
                                                                                                                                                • +

                                                                                                                                                  T4

                                                                                                                                                  • +
                                                                                                                                                • +

                                                                                                                                                  T5

                                                                                                                                                +
                                                                                                                                                +

                                                                                                                                                Parameters

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • +
                                                                                                                                                  this: AsyncIterable<T>
                                                                                                                                                  • +
                                                                                                                                                • +
                                                                                                                                                  source2: AsyncIterable<T2>
                                                                                                                                                  • +
                                                                                                                                                • +
                                                                                                                                                  source3: AsyncIterable<T3>
                                                                                                                                                  • +
                                                                                                                                                • +
                                                                                                                                                  source4: AsyncIterable<T4>
                                                                                                                                                  • +
                                                                                                                                                • +
                                                                                                                                                  source5: AsyncIterable<T5>
                                                                                                                                                +

                                                                                                                                                Returns AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                                • +
                                                                                                                                              • <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>
                                                                                                                                                • +
                                                                                                                                              • +
                                                                                                                                                +

                                                                                                                                                Type Parameters

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • +

                                                                                                                                                  T

                                                                                                                                                  • +
                                                                                                                                                • +

                                                                                                                                                  T2

                                                                                                                                                  • +
                                                                                                                                                • +

                                                                                                                                                  T3

                                                                                                                                                  • +
                                                                                                                                                • +

                                                                                                                                                  T4

                                                                                                                                                  • +
                                                                                                                                                • +

                                                                                                                                                  T5

                                                                                                                                                  • +
                                                                                                                                                • +

                                                                                                                                                  T6

                                                                                                                                                +
                                                                                                                                                +

                                                                                                                                                Parameters

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • +
                                                                                                                                                  this: AsyncIterable<T>
                                                                                                                                                  • +
                                                                                                                                                • +
                                                                                                                                                  source2: AsyncIterable<T2>
                                                                                                                                                  • +
                                                                                                                                                • +
                                                                                                                                                  source3: AsyncIterable<T3>
                                                                                                                                                  • +
                                                                                                                                                • +
                                                                                                                                                  source4: AsyncIterable<T4>
                                                                                                                                                  • +
                                                                                                                                                • +
                                                                                                                                                  source5: AsyncIterable<T5>
                                                                                                                                                  • +
                                                                                                                                                • +
                                                                                                                                                  source6: AsyncIterable<T6>
                                                                                                                                                +

                                                                                                                                                Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                • +
                                                                                                                                              • <T>(this, ...sources): AsyncIterable<T[]>
                                                                                                                                                • +
                                                                                                                                              • +
                                                                                                                                                +

                                                                                                                                                Type Parameters

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • +

                                                                                                                                                  T

                                                                                                                                                +
                                                                                                                                                +

                                                                                                                                                Parameters

                                                                                                                                                +
                                                                                                                                                +

                                                                                                                                                Returns AsyncIterable<T[]>

                                                                                                                                            +
                                                                                                                                            +

                                                                                                                                            concat

                                                                                                                                            +
                                                                                                                                            concat: {}
                                                                                                                                            +
                                                                                                                                            +

                                                                                                                                            Type declaration

                                                                                                                                            +
                                                                                                                                              +
                                                                                                                                            • +
                                                                                                                                              +
                                                                                                                                              +

                                                                                                                                              concatAll

                                                                                                                                              +
                                                                                                                                              concatAll: {}
                                                                                                                                              +
                                                                                                                                              +

                                                                                                                                              Type declaration

                                                                                                                                              +
                                                                                                                                                +
                                                                                                                                              • +
                                                                                                                                                +
                                                                                                                                                +

                                                                                                                                                concatMap

                                                                                                                                                +
                                                                                                                                                concatMap: {}
                                                                                                                                                +
                                                                                                                                                +

                                                                                                                                                Type declaration

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • +
                                                                                                                                                  +
                                                                                                                                                  +

                                                                                                                                                  count

                                                                                                                                                  +
                                                                                                                                                  count: {}
                                                                                                                                                  +
                                                                                                                                                  +

                                                                                                                                                  Type declaration

                                                                                                                                                  +
                                                                                                                                                    +
                                                                                                                                                  • +
                                                                                                                                                    +
                                                                                                                                                    +

                                                                                                                                                    debounce

                                                                                                                                                    +
                                                                                                                                                    debounce: {}
                                                                                                                                                    +
                                                                                                                                                    +

                                                                                                                                                    Type declaration

                                                                                                                                                    +
                                                                                                                                                      +
                                                                                                                                                    • +
                                                                                                                                                      +
                                                                                                                                                      +

                                                                                                                                                      defaultIfEmpty

                                                                                                                                                      +
                                                                                                                                                      defaultIfEmpty: {}
                                                                                                                                                      +
                                                                                                                                                      +

                                                                                                                                                      Type declaration

                                                                                                                                                      +
                                                                                                                                                        +
                                                                                                                                                      • +
                                                                                                                                                        +
                                                                                                                                                        +

                                                                                                                                                        delay

                                                                                                                                                        +
                                                                                                                                                        delay: (<TSource>(this, dueTime) => AsyncIterable<TSource>)
                                                                                                                                                        +
                                                                                                                                                        +

                                                                                                                                                        Type declaration

                                                                                                                                                        +
                                                                                                                                                        +
                                                                                                                                                        +

                                                                                                                                                        delayEach

                                                                                                                                                        +
                                                                                                                                                        delayEach: (<TSource>(this, dueTime) => AsyncIterable<TSource>)
                                                                                                                                                        +
                                                                                                                                                        +

                                                                                                                                                        Type declaration

                                                                                                                                                        +
                                                                                                                                                        +
                                                                                                                                                        +

                                                                                                                                                        distinct

                                                                                                                                                        +
                                                                                                                                                        distinct: {}
                                                                                                                                                        +
                                                                                                                                                        +

                                                                                                                                                        Type declaration

                                                                                                                                                        +
                                                                                                                                                          +
                                                                                                                                                        • +
                                                                                                                                                          +
                                                                                                                                                          +

                                                                                                                                                          distinctUntilChanged

                                                                                                                                                          +
                                                                                                                                                          distinctUntilChanged: {}
                                                                                                                                                          +
                                                                                                                                                          +

                                                                                                                                                          Type declaration

                                                                                                                                                          +
                                                                                                                                                            +
                                                                                                                                                          • +
                                                                                                                                                            +
                                                                                                                                                            +

                                                                                                                                                            doWhile

                                                                                                                                                            +
                                                                                                                                                            doWhile: {}
                                                                                                                                                            +
                                                                                                                                                            +

                                                                                                                                                            Type declaration

                                                                                                                                                            +
                                                                                                                                                              +
                                                                                                                                                            • +
                                                                                                                                                              +
                                                                                                                                                              +

                                                                                                                                                              elementAt

                                                                                                                                                              +
                                                                                                                                                              elementAt: {}
                                                                                                                                                              +
                                                                                                                                                              +

                                                                                                                                                              Type declaration

                                                                                                                                                              +
                                                                                                                                                                +
                                                                                                                                                              • +
                                                                                                                                                                +
                                                                                                                                                                +

                                                                                                                                                                endWith

                                                                                                                                                                +
                                                                                                                                                                endWith: {}
                                                                                                                                                                +
                                                                                                                                                                +

                                                                                                                                                                Type declaration

                                                                                                                                                                +
                                                                                                                                                                  +
                                                                                                                                                                • +
                                                                                                                                                                  +
                                                                                                                                                                  +

                                                                                                                                                                  every

                                                                                                                                                                  +
                                                                                                                                                                  every: {}
                                                                                                                                                                  +
                                                                                                                                                                  +

                                                                                                                                                                  Type declaration

                                                                                                                                                                  +
                                                                                                                                                                    +
                                                                                                                                                                  • +
                                                                                                                                                                    +
                                                                                                                                                                    +

                                                                                                                                                                    except

                                                                                                                                                                    +
                                                                                                                                                                    except: {}
                                                                                                                                                                    +
                                                                                                                                                                    +

                                                                                                                                                                    Type declaration

                                                                                                                                                                    +
                                                                                                                                                                      +
                                                                                                                                                                    • +
                                                                                                                                                                      +
                                                                                                                                                                      +

                                                                                                                                                                      expand

                                                                                                                                                                      +
                                                                                                                                                                      expand: {}
                                                                                                                                                                      +
                                                                                                                                                                      +

                                                                                                                                                                      Type declaration

                                                                                                                                                                      +
                                                                                                                                                                        +
                                                                                                                                                                      • +
                                                                                                                                                                        +
                                                                                                                                                                        +

                                                                                                                                                                        filter

                                                                                                                                                                        +
                                                                                                                                                                        filter: (<T>(this, predicate, thisArg?) => AsyncIterable<T>)
                                                                                                                                                                        +
                                                                                                                                                                        +

                                                                                                                                                                        Type declaration

                                                                                                                                                                        +
                                                                                                                                                                          +
                                                                                                                                                                        • +
                                                                                                                                                                            +
                                                                                                                                                                          • <T>(this, predicate, thisArg?): AsyncIterable<T>
                                                                                                                                                                            • +
                                                                                                                                                                          • +
                                                                                                                                                                            +

                                                                                                                                                                            Type Parameters

                                                                                                                                                                            +
                                                                                                                                                                              +
                                                                                                                                                                            • +

                                                                                                                                                                              T

                                                                                                                                                                            +
                                                                                                                                                                            +

                                                                                                                                                                            Parameters

                                                                                                                                                                            +
                                                                                                                                                                              +
                                                                                                                                                                            • +
                                                                                                                                                                              this: AsyncIterable<T>
                                                                                                                                                                              • +
                                                                                                                                                                            • +
                                                                                                                                                                              predicate: ((value, index, signal?) => boolean | Promise<boolean>)
                                                                                                                                                                              +
                                                                                                                                                                                +
                                                                                                                                                                              • +
                                                                                                                                                                                  +
                                                                                                                                                                                • (value, index, signal?): boolean | Promise<boolean>
                                                                                                                                                                                  • +
                                                                                                                                                                                • +
                                                                                                                                                                                  +

                                                                                                                                                                                  Parameters

                                                                                                                                                                                  +
                                                                                                                                                                                    +
                                                                                                                                                                                  • +
                                                                                                                                                                                    value: T
                                                                                                                                                                                    • +
                                                                                                                                                                                  • +
                                                                                                                                                                                    index: number
                                                                                                                                                                                    • +
                                                                                                                                                                                  • +
                                                                                                                                                                                    Optional signal: AbortSignal
                                                                                                                                                                                  +

                                                                                                                                                                                  Returns boolean | Promise<boolean>

                                                                                                                                                                              • +
                                                                                                                                                                            • +
                                                                                                                                                                              Optional thisArg: any
                                                                                                                                                                            +

                                                                                                                                                                            Returns AsyncIterable<T>

                                                                                                                                                                        +
                                                                                                                                                                        +

                                                                                                                                                                        finalize

                                                                                                                                                                        +
                                                                                                                                                                        finalize: {}
                                                                                                                                                                        +
                                                                                                                                                                        +

                                                                                                                                                                        Type declaration

                                                                                                                                                                        +
                                                                                                                                                                          +
                                                                                                                                                                        • +
                                                                                                                                                                          +
                                                                                                                                                                          +

                                                                                                                                                                          find

                                                                                                                                                                          +
                                                                                                                                                                          find: {}
                                                                                                                                                                          +
                                                                                                                                                                          +

                                                                                                                                                                          Type declaration

                                                                                                                                                                          +
                                                                                                                                                                            +
                                                                                                                                                                          • +
                                                                                                                                                                            +
                                                                                                                                                                            +

                                                                                                                                                                            findIndex

                                                                                                                                                                            +
                                                                                                                                                                            findIndex: {}
                                                                                                                                                                            +
                                                                                                                                                                            +

                                                                                                                                                                            Type declaration

                                                                                                                                                                            +
                                                                                                                                                                              +
                                                                                                                                                                            • +
                                                                                                                                                                              +
                                                                                                                                                                              +

                                                                                                                                                                              first

                                                                                                                                                                              +
                                                                                                                                                                              first: {}
                                                                                                                                                                              +
                                                                                                                                                                              +

                                                                                                                                                                              Type declaration

                                                                                                                                                                              +
                                                                                                                                                                                +
                                                                                                                                                                              • +
                                                                                                                                                                                +
                                                                                                                                                                                +

                                                                                                                                                                                flat

                                                                                                                                                                                +
                                                                                                                                                                                flat: {}
                                                                                                                                                                                +
                                                                                                                                                                                +

                                                                                                                                                                                Type declaration

                                                                                                                                                                                +
                                                                                                                                                                                  +
                                                                                                                                                                                • +
                                                                                                                                                                                  +
                                                                                                                                                                                  +

                                                                                                                                                                                  flatMap

                                                                                                                                                                                  +
                                                                                                                                                                                  flatMap: {}
                                                                                                                                                                                  +
                                                                                                                                                                                  +

                                                                                                                                                                                  Type declaration

                                                                                                                                                                                  +
                                                                                                                                                                                    +
                                                                                                                                                                                  • +
                                                                                                                                                                                    +
                                                                                                                                                                                    +

                                                                                                                                                                                    forkJoin

                                                                                                                                                                                    +
                                                                                                                                                                                    forkJoin: {
                                                                                                                                                                                        <T, T2, T3>(this, source2, source3): Promise<[T, T2, T3] | undefined>;
                                                                                                                                                                                        <T, T2, T3, T4>(this, source2, source3, source4): Promise<[T, T2, T3, T4] | undefined>;
                                                                                                                                                                                        <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): Promise<[T, T2, T3, T4, T5] | undefined>;
                                                                                                                                                                                        <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): Promise<[T, T2, T3, T4, T5, T6] | undefined>;
                                                                                                                                                                                        <T>(this, ...sources): Promise<T[] | undefined>;
                                                                                                                                                                                    }
                                                                                                                                                                                    +
                                                                                                                                                                                    +

                                                                                                                                                                                    Type declaration

                                                                                                                                                                                    +
                                                                                                                                                                                      +
                                                                                                                                                                                    • +
                                                                                                                                                                                        +
                                                                                                                                                                                      • <T, T2, T3>(this, source2, source3): Promise<[T, T2, T3] | undefined>
                                                                                                                                                                                        • +
                                                                                                                                                                                      • +
                                                                                                                                                                                        +

                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T2

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T3

                                                                                                                                                                                        +
                                                                                                                                                                                        +

                                                                                                                                                                                        Parameters

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • +
                                                                                                                                                                                          this: AsyncIterable<T>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          source2: AsyncIterable<T2>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          source3: AsyncIterable<T3>
                                                                                                                                                                                        +

                                                                                                                                                                                        Returns Promise<[T, T2, T3] | undefined>

                                                                                                                                                                                        • +
                                                                                                                                                                                      • <T, T2, T3, T4>(this, source2, source3, source4): Promise<[T, T2, T3, T4] | undefined>
                                                                                                                                                                                        • +
                                                                                                                                                                                      • +
                                                                                                                                                                                        +

                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T2

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T3

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T4

                                                                                                                                                                                        +
                                                                                                                                                                                        +

                                                                                                                                                                                        Parameters

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • +
                                                                                                                                                                                          this: AsyncIterable<T>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          source2: AsyncIterable<T2>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          source3: AsyncIterable<T3>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          source4: AsyncIterable<T4>
                                                                                                                                                                                        +

                                                                                                                                                                                        Returns Promise<[T, T2, T3, T4] | undefined>

                                                                                                                                                                                        • +
                                                                                                                                                                                      • <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): Promise<[T, T2, T3, T4, T5] | undefined>
                                                                                                                                                                                        • +
                                                                                                                                                                                      • +
                                                                                                                                                                                        +

                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T2

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T3

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T4

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T5

                                                                                                                                                                                        +
                                                                                                                                                                                        +

                                                                                                                                                                                        Parameters

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • +
                                                                                                                                                                                          this: AsyncIterable<T>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          source2: AsyncIterable<T2>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          source3: AsyncIterable<T3>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          source4: AsyncIterable<T4>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          source5: AsyncIterable<T5>
                                                                                                                                                                                        +

                                                                                                                                                                                        Returns Promise<[T, T2, T3, T4, T5] | undefined>

                                                                                                                                                                                        • +
                                                                                                                                                                                      • <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): Promise<[T, T2, T3, T4, T5, T6] | undefined>
                                                                                                                                                                                        • +
                                                                                                                                                                                      • +
                                                                                                                                                                                        +

                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T2

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T3

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T4

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T5

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T6

                                                                                                                                                                                        +
                                                                                                                                                                                        +

                                                                                                                                                                                        Parameters

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • +
                                                                                                                                                                                          this: AsyncIterable<T>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          source2: AsyncIterable<T2>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          source3: AsyncIterable<T3>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          source4: AsyncIterable<T4>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          source5: AsyncIterable<T5>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          source6: AsyncIterable<T6>
                                                                                                                                                                                        +

                                                                                                                                                                                        Returns Promise<[T, T2, T3, T4, T5, T6] | undefined>

                                                                                                                                                                                        • +
                                                                                                                                                                                      • <T>(this, ...sources): Promise<T[] | undefined>
                                                                                                                                                                                        • +
                                                                                                                                                                                      • +
                                                                                                                                                                                        +

                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • +

                                                                                                                                                                                          T

                                                                                                                                                                                        +
                                                                                                                                                                                        +

                                                                                                                                                                                        Parameters

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • +
                                                                                                                                                                                          this: AsyncIterable<T>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          Rest ...sources: AsyncIterable<T>[]
                                                                                                                                                                                        +

                                                                                                                                                                                        Returns Promise<T[] | undefined>

                                                                                                                                                                                    +
                                                                                                                                                                                    +

                                                                                                                                                                                    groupBy

                                                                                                                                                                                    +
                                                                                                                                                                                    groupBy: {
                                                                                                                                                                                        <TSource, TKey>(this, keySelector): AsyncIterable<GroupedAsyncIterable<TKey, TSource>>;
                                                                                                                                                                                        <TSource, TKey, TValue>(this, keySelector, elementSelector?): AsyncIterable<GroupedAsyncIterable<TKey, TValue>>;
                                                                                                                                                                                    }
                                                                                                                                                                                    +
                                                                                                                                                                                    +

                                                                                                                                                                                    Type declaration

                                                                                                                                                                                    +
                                                                                                                                                                                      +
                                                                                                                                                                                    • +
                                                                                                                                                                                        +
                                                                                                                                                                                      • <TSource, TKey>(this, keySelector): AsyncIterable<GroupedAsyncIterable<TKey, TSource>>
                                                                                                                                                                                        • +
                                                                                                                                                                                      • +
                                                                                                                                                                                        +

                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • +

                                                                                                                                                                                          TSource

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          TKey

                                                                                                                                                                                        +
                                                                                                                                                                                        +

                                                                                                                                                                                        Parameters

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • +
                                                                                                                                                                                          this: AsyncIterable<TSource>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          keySelector: ((value, signal?) => TKey | Promise<TKey>)
                                                                                                                                                                                          +
                                                                                                                                                                                            +
                                                                                                                                                                                          • +
                                                                                                                                                                                              +
                                                                                                                                                                                            • (value, signal?): TKey | Promise<TKey>
                                                                                                                                                                                              • +
                                                                                                                                                                                            • +
                                                                                                                                                                                              +

                                                                                                                                                                                              Parameters

                                                                                                                                                                                              +
                                                                                                                                                                                                +
                                                                                                                                                                                              • +
                                                                                                                                                                                                value: TSource
                                                                                                                                                                                                • +
                                                                                                                                                                                              • +
                                                                                                                                                                                                Optional signal: AbortSignal
                                                                                                                                                                                              +

                                                                                                                                                                                              Returns TKey | Promise<TKey>

                                                                                                                                                                                        +

                                                                                                                                                                                        Returns AsyncIterable<GroupedAsyncIterable<TKey, TSource>>

                                                                                                                                                                                        • +
                                                                                                                                                                                      • <TSource, TKey, TValue>(this, keySelector, elementSelector?): AsyncIterable<GroupedAsyncIterable<TKey, TValue>>
                                                                                                                                                                                        • +
                                                                                                                                                                                      • +
                                                                                                                                                                                        +

                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • +

                                                                                                                                                                                          TSource

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          TKey

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +

                                                                                                                                                                                          TValue

                                                                                                                                                                                        +
                                                                                                                                                                                        +

                                                                                                                                                                                        Parameters

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • +
                                                                                                                                                                                          this: AsyncIterable<TSource>
                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          keySelector: ((value, signal?) => TKey | Promise<TKey>)
                                                                                                                                                                                          +
                                                                                                                                                                                            +
                                                                                                                                                                                          • +
                                                                                                                                                                                              +
                                                                                                                                                                                            • (value, signal?): TKey | Promise<TKey>
                                                                                                                                                                                              • +
                                                                                                                                                                                            • +
                                                                                                                                                                                              +

                                                                                                                                                                                              Parameters

                                                                                                                                                                                              +
                                                                                                                                                                                                +
                                                                                                                                                                                              • +
                                                                                                                                                                                                value: TSource
                                                                                                                                                                                                • +
                                                                                                                                                                                              • +
                                                                                                                                                                                                Optional signal: AbortSignal
                                                                                                                                                                                              +

                                                                                                                                                                                              Returns TKey | Promise<TKey>

                                                                                                                                                                                          • +
                                                                                                                                                                                        • +
                                                                                                                                                                                          Optional elementSelector: ((value, signal?) => TValue | Promise<TValue>)
                                                                                                                                                                                          +
                                                                                                                                                                                            +
                                                                                                                                                                                          • +
                                                                                                                                                                                              +
                                                                                                                                                                                            • (value, signal?): TValue | Promise<TValue>
                                                                                                                                                                                              • +
                                                                                                                                                                                            • +
                                                                                                                                                                                              +

                                                                                                                                                                                              Parameters

                                                                                                                                                                                              +
                                                                                                                                                                                                +
                                                                                                                                                                                              • +
                                                                                                                                                                                                value: TSource
                                                                                                                                                                                                • +
                                                                                                                                                                                              • +
                                                                                                                                                                                                Optional signal: AbortSignal
                                                                                                                                                                                              +

                                                                                                                                                                                              Returns TValue | Promise<TValue>

                                                                                                                                                                                        +

                                                                                                                                                                                        Returns AsyncIterable<GroupedAsyncIterable<TKey, TValue>>

                                                                                                                                                                                    +
                                                                                                                                                                                    +

                                                                                                                                                                                    groupJoin

                                                                                                                                                                                    +
                                                                                                                                                                                    groupJoin: {}
                                                                                                                                                                                    +
                                                                                                                                                                                    +

                                                                                                                                                                                    Type declaration

                                                                                                                                                                                    +
                                                                                                                                                                                      +
                                                                                                                                                                                    • +
                                                                                                                                                                                      +
                                                                                                                                                                                      +

                                                                                                                                                                                      ignoreElements

                                                                                                                                                                                      +
                                                                                                                                                                                      ignoreElements: {}
                                                                                                                                                                                      +
                                                                                                                                                                                      +

                                                                                                                                                                                      Type declaration

                                                                                                                                                                                      +
                                                                                                                                                                                        +
                                                                                                                                                                                      • +
                                                                                                                                                                                        +
                                                                                                                                                                                        +

                                                                                                                                                                                        includes

                                                                                                                                                                                        +
                                                                                                                                                                                        includes: {}
                                                                                                                                                                                        +
                                                                                                                                                                                        +

                                                                                                                                                                                        Type declaration

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • +
                                                                                                                                                                                          +
                                                                                                                                                                                          +

                                                                                                                                                                                          innerJoin

                                                                                                                                                                                          +
                                                                                                                                                                                          innerJoin: {}
                                                                                                                                                                                          +
                                                                                                                                                                                          +

                                                                                                                                                                                          Type declaration

                                                                                                                                                                                          +
                                                                                                                                                                                            +
                                                                                                                                                                                          • +
                                                                                                                                                                                            +
                                                                                                                                                                                            +

                                                                                                                                                                                            intersect

                                                                                                                                                                                            +
                                                                                                                                                                                            intersect: {}
                                                                                                                                                                                            +
                                                                                                                                                                                            +

                                                                                                                                                                                            Type declaration

                                                                                                                                                                                            +
                                                                                                                                                                                              +
                                                                                                                                                                                            • +
                                                                                                                                                                                              +
                                                                                                                                                                                              +

                                                                                                                                                                                              isEmpty

                                                                                                                                                                                              +
                                                                                                                                                                                              isEmpty: {}
                                                                                                                                                                                              +
                                                                                                                                                                                              +

                                                                                                                                                                                              Type declaration

                                                                                                                                                                                              +
                                                                                                                                                                                                +
                                                                                                                                                                                              • +
                                                                                                                                                                                                +
                                                                                                                                                                                                +

                                                                                                                                                                                                last

                                                                                                                                                                                                +
                                                                                                                                                                                                last: {}
                                                                                                                                                                                                +
                                                                                                                                                                                                +

                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                +
                                                                                                                                                                                                  +
                                                                                                                                                                                                • +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  +

                                                                                                                                                                                                  map

                                                                                                                                                                                                  +
                                                                                                                                                                                                  map: {}
                                                                                                                                                                                                  +
                                                                                                                                                                                                  +

                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                  +
                                                                                                                                                                                                    +
                                                                                                                                                                                                  • +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    +

                                                                                                                                                                                                    max

                                                                                                                                                                                                    +
                                                                                                                                                                                                    max: (<TSource, TResult>(this, options?) => Promise<TResult>)
                                                                                                                                                                                                    +
                                                                                                                                                                                                    +

                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                    +
                                                                                                                                                                                                      +
                                                                                                                                                                                                    • +
                                                                                                                                                                                                        +
                                                                                                                                                                                                      • <TSource, TResult>(this, options?): Promise<TResult>
                                                                                                                                                                                                        • +
                                                                                                                                                                                                      • +
                                                                                                                                                                                                        +

                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                        +
                                                                                                                                                                                                          +
                                                                                                                                                                                                        • +

                                                                                                                                                                                                          TSource

                                                                                                                                                                                                          • +
                                                                                                                                                                                                        • +

                                                                                                                                                                                                          TResult = TSource

                                                                                                                                                                                                        +
                                                                                                                                                                                                        +

                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                        +
                                                                                                                                                                                                          +
                                                                                                                                                                                                        • +
                                                                                                                                                                                                          this: AsyncIterable<TSource>
                                                                                                                                                                                                          • +
                                                                                                                                                                                                        • +
                                                                                                                                                                                                          Optional options: ExtremaOptions<TSource, TResult>
                                                                                                                                                                                                        +

                                                                                                                                                                                                        Returns Promise<TResult>

                                                                                                                                                                                                    +
                                                                                                                                                                                                    +

                                                                                                                                                                                                    maxBy

                                                                                                                                                                                                    +
                                                                                                                                                                                                    maxBy: {}
                                                                                                                                                                                                    +
                                                                                                                                                                                                    +

                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                    +
                                                                                                                                                                                                      +
                                                                                                                                                                                                    • +
                                                                                                                                                                                                      +
                                                                                                                                                                                                      +

                                                                                                                                                                                                      memoize

                                                                                                                                                                                                      +
                                                                                                                                                                                                      memoize: {
                                                                                                                                                                                                          <T>(this, readerCount?): AsyncIterable<T>;
                                                                                                                                                                                                          <T, R>(this, readerCount?, selector?): AsyncIterable<R>;
                                                                                                                                                                                                      }
                                                                                                                                                                                                      +
                                                                                                                                                                                                      +

                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                      +
                                                                                                                                                                                                        +
                                                                                                                                                                                                      • +
                                                                                                                                                                                                          +
                                                                                                                                                                                                        • <T>(this, readerCount?): AsyncIterable<T>
                                                                                                                                                                                                          • +
                                                                                                                                                                                                        • +
                                                                                                                                                                                                          +

                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                          +
                                                                                                                                                                                                            +
                                                                                                                                                                                                          • +

                                                                                                                                                                                                            T

                                                                                                                                                                                                          +
                                                                                                                                                                                                          +

                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                          +
                                                                                                                                                                                                          +

                                                                                                                                                                                                          Returns AsyncIterable<T>

                                                                                                                                                                                                          • +
                                                                                                                                                                                                        • <T, R>(this, readerCount?, selector?): AsyncIterable<R>
                                                                                                                                                                                                          • +
                                                                                                                                                                                                        • +
                                                                                                                                                                                                          +

                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                          +
                                                                                                                                                                                                            +
                                                                                                                                                                                                          • +

                                                                                                                                                                                                            T

                                                                                                                                                                                                            • +
                                                                                                                                                                                                          • +

                                                                                                                                                                                                            R

                                                                                                                                                                                                          +
                                                                                                                                                                                                          +

                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                          +
                                                                                                                                                                                                            +
                                                                                                                                                                                                          • +
                                                                                                                                                                                                            this: AsyncIterable<T>
                                                                                                                                                                                                            • +
                                                                                                                                                                                                          • +
                                                                                                                                                                                                            Optional readerCount: number
                                                                                                                                                                                                            • +
                                                                                                                                                                                                          • +
                                                                                                                                                                                                            Optional selector: ((value, signal?) => AsyncIterable<R>)
                                                                                                                                                                                                            +
                                                                                                                                                                                                              +
                                                                                                                                                                                                            • +
                                                                                                                                                                                                                +
                                                                                                                                                                                                              • (value, signal?): AsyncIterable<R>
                                                                                                                                                                                                                • +
                                                                                                                                                                                                              • +
                                                                                                                                                                                                                +

                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                • +
                                                                                                                                                                                                                  value: AsyncIterable<T>
                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                • +
                                                                                                                                                                                                                  Optional signal: AbortSignal
                                                                                                                                                                                                                +

                                                                                                                                                                                                                Returns AsyncIterable<R>

                                                                                                                                                                                                          +

                                                                                                                                                                                                          Returns AsyncIterable<R>

                                                                                                                                                                                                      +
                                                                                                                                                                                                      +

                                                                                                                                                                                                      merge

                                                                                                                                                                                                      +
                                                                                                                                                                                                      merge: {}
                                                                                                                                                                                                      +
                                                                                                                                                                                                      +

                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                      +
                                                                                                                                                                                                        +
                                                                                                                                                                                                      • +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        +

                                                                                                                                                                                                        mergeAll

                                                                                                                                                                                                        +
                                                                                                                                                                                                        mergeAll: {}
                                                                                                                                                                                                        +
                                                                                                                                                                                                        +

                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                        +
                                                                                                                                                                                                          +
                                                                                                                                                                                                        • +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          +

                                                                                                                                                                                                          min

                                                                                                                                                                                                          +
                                                                                                                                                                                                          min: (<TSource, TResult>(this, options?) => Promise<TResult>)
                                                                                                                                                                                                          +
                                                                                                                                                                                                          +

                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                          +
                                                                                                                                                                                                            +
                                                                                                                                                                                                          • +
                                                                                                                                                                                                              +
                                                                                                                                                                                                            • <TSource, TResult>(this, options?): Promise<TResult>
                                                                                                                                                                                                              • +
                                                                                                                                                                                                            • +
                                                                                                                                                                                                              +

                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                              +
                                                                                                                                                                                                                +
                                                                                                                                                                                                              • +

                                                                                                                                                                                                                TSource

                                                                                                                                                                                                                • +
                                                                                                                                                                                                              • +

                                                                                                                                                                                                                TResult = TSource

                                                                                                                                                                                                              +
                                                                                                                                                                                                              +

                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                              +
                                                                                                                                                                                                                +
                                                                                                                                                                                                              • +
                                                                                                                                                                                                                this: AsyncIterable<TSource>
                                                                                                                                                                                                                • +
                                                                                                                                                                                                              • +
                                                                                                                                                                                                                Optional options: ExtremaOptions<TSource, TResult>
                                                                                                                                                                                                              +

                                                                                                                                                                                                              Returns Promise<TResult>

                                                                                                                                                                                                          +
                                                                                                                                                                                                          +

                                                                                                                                                                                                          minBy

                                                                                                                                                                                                          +
                                                                                                                                                                                                          minBy: {}
                                                                                                                                                                                                          +
                                                                                                                                                                                                          +

                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                          +
                                                                                                                                                                                                            +
                                                                                                                                                                                                          • +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            +

                                                                                                                                                                                                            onErrorResumeNext

                                                                                                                                                                                                            +
                                                                                                                                                                                                            onErrorResumeNext: {}
                                                                                                                                                                                                            +
                                                                                                                                                                                                            +

                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                            +
                                                                                                                                                                                                              +
                                                                                                                                                                                                            • +
                                                                                                                                                                                                              +
                                                                                                                                                                                                              +

                                                                                                                                                                                                              orderBy

                                                                                                                                                                                                              +
                                                                                                                                                                                                              orderBy: {}
                                                                                                                                                                                                              +
                                                                                                                                                                                                              +

                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                              +
                                                                                                                                                                                                                +
                                                                                                                                                                                                              • +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                +

                                                                                                                                                                                                                orderByDescending

                                                                                                                                                                                                                +
                                                                                                                                                                                                                orderByDescending: {}
                                                                                                                                                                                                                +
                                                                                                                                                                                                                +

                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                • +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +

                                                                                                                                                                                                                  pairwise

                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  pairwise: {}
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +

                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                  +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +

                                                                                                                                                                                                                    pluck

                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    pluck: {}
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +

                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                    +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      publish

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      publish: {
                                                                                                                                                                                                                          <TSource>(this): AsyncIterable<TSource>;
                                                                                                                                                                                                                          <TSource, TResult>(this, selector?): AsyncIterable<TResult>;
                                                                                                                                                                                                                      }
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                        • <TSource>(this): AsyncIterable<TSource>
                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                            TSource

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Returns AsyncIterable<TSource>

                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                        • <TSource, TResult>(this, selector?): AsyncIterable<TResult>
                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                            TSource

                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                            TResult

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                            this: AsyncIterable<TSource>
                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                            Optional selector: ((value) => AsyncIterable<TResult>)
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                              • (value): AsyncIterable<TResult>
                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                  value: AsyncIterable<TSource>
                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                Returns AsyncIterable<TResult>

                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Returns AsyncIterable<TResult>

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      reduce

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      reduce: {}
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        +

                                                                                                                                                                                                                        reduceRight

                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        reduceRight: {}
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        +

                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                        +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          repeat

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          repeat: {}
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            +

                                                                                                                                                                                                                            retry

                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            retry: {}
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            +

                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                            +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              +

                                                                                                                                                                                                                              reverse

                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              reverse: {}
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              +

                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                scan

                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                scan: {}
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                  scanRight

                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  scanRight: {}
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                    sequenceEqual

                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    sequenceEqual: {}
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                      share

                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      share: {
                                                                                                                                                                                                                                          <TSource>(this): AsyncIterable<TSource>;
                                                                                                                                                                                                                                          <TSource, TResult>(this, selector?): AsyncIterable<TResult>;
                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                        • <TSource>(this): AsyncIterable<TSource>
                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                            TSource

                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                          Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                        • <TSource, TResult>(this, selector?): AsyncIterable<TResult>
                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                            TSource

                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                            TResult

                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                            this: AsyncIterable<TSource>
                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                            Optional selector: ((value) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>)
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                              • (value): AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>
                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                  value: AsyncIterable<TSource>
                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                Returns AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>

                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                          Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                      single

                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      single: {}
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                        skip

                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        skip: {}
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                          skipLast

                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          skipLast: {}
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                            skipUntil

                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            skipUntil: {}
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              skipWhile

                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              skipWhile: (<T>(this, predicate) => AsyncIterable<T>)
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                • <T>(this, predicate): AsyncIterable<T>
                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                    this: AsyncIterable<T>
                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                    predicate: ((value, index, signal?) => boolean | Promise<boolean>)
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                      • (value, index, signal?): boolean | Promise<boolean>
                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                          value: T
                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                          index: number
                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                          Optional signal: AbortSignal
                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                        Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                  Returns AsyncIterable<T>

                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              slice

                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              slice: {}
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                some

                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                some: {}
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                  startWith

                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  startWith: {}
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                    sum

                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    sum: {
                                                                                                                                                                                                                                                        (this, options?): Promise<number>;
                                                                                                                                                                                                                                                        <T>(this, options?): Promise<number>;
                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                      • (this, options?): Promise<number>
                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                          this: AsyncIterable<number>
                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                          Optional options: MathOptions<number>
                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                        Returns Promise<number>

                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                      • <T>(this, options?): Promise<number>
                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                          T

                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                          this: AsyncIterable<T>
                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                          Optional options: MathOptions<T>
                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                        Returns Promise<number>

                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                    switchAll

                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    switchAll: {}
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                      switchMap

                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      switchMap: {}
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                        take

                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        take: {}
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                          takeLast

                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          takeLast: {}
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                            takeUntil

                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            takeUntil: {}
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                              takeWhile

                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              takeWhile: (<T>(this, predicate) => AsyncIterable<T>)
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                • <T>(this, predicate): AsyncIterable<T>
                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                    this: AsyncIterable<T>
                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                    predicate: ((value, index, signal?) => boolean | Promise<boolean>)
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                      • (value, index, signal?): boolean | Promise<boolean>
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                          value: T
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                          index: number
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                          Optional signal: AbortSignal
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                  Returns AsyncIterable<T>

                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                              tap

                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              tap: {}
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                throttle

                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                throttle: {}
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                  toArray

                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  toArray: {}
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                    toDOMStream

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    toDOMStream: {
                                                                                                                                                                                                                                                                        <T>(this, options): ReadableStream<Uint8Array>;
                                                                                                                                                                                                                                                                        <T>(this, options): ReadableStream<Uint8Array>;
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                      • <T>(this, options): ReadableStream<Uint8Array>
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                          T

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                          this: AsyncIterable<T>
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                          options: ReadableBYOBStreamOptions<Uint8Array>
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                      • <T>(this, options): ReadableStream<Uint8Array>
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                          T

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                          this: AsyncIterable<T>
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                          options: ReadableByteStreamOptions<Uint8Array>
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                    toMap

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    toMap: (<TSource, TKey, TElement>(this, options) => Promise<Map<TKey, TElement | TSource>>)
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                      • <TSource, TKey, TElement>(this, options): Promise<Map<TKey, TElement | TSource>>
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                          TKey

                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                          TElement = TSource

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                          this: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                          options: ToMapOptions<TSource, TKey, TElement>
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Returns Promise<Map<TKey, TElement | TSource>>

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                    toNodeStream

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    toNodeStream: {
                                                                                                                                                                                                                                                                        <TSource>(this, options): AsyncIterableReadable<TSource>;
                                                                                                                                                                                                                                                                        <TSource>(this, options): AsyncIterableReadable<TSource>;
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                      • <TSource>(this, options): AsyncIterableReadable<TSource>
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                          this: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                          options: ReadableOptions & {
                                                                                                                                                                                                                                                                              objectMode: true;
                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Returns AsyncIterableReadable<TSource>

                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                      • <TSource>(this, options): AsyncIterableReadable<TSource>
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                          TSource extends BufferLike

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                          this: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                          options: ReadableOptions & {
                                                                                                                                                                                                                                                                              objectMode: false;
                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Returns AsyncIterableReadable<TSource>

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                    toObservable

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    toObservable: {}
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                      toSet

                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      toSet: {}
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        union

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        union: {}
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          withLatestFrom

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          withLatestFrom: {
                                                                                                                                                                                                                                                                              <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>;
                                                                                                                                                                                                                                                                              <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>;
                                                                                                                                                                                                                                                                              <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>;
                                                                                                                                                                                                                                                                              <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>;
                                                                                                                                                                                                                                                                              <T>(this, ...sources): AsyncIterable<T[]>;
                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T2

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T3

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                this: AsyncIterable<T>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Returns AsyncIterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T2

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T3

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T4

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                this: AsyncIterable<T>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Returns AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T2

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T3

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T4

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T5

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                this: AsyncIterable<T>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Returns AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T2

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T3

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T4

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T5

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T6

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                this: AsyncIterable<T>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • <T>(this, ...sources): AsyncIterable<T[]>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Returns AsyncIterable<T[]>

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          zip

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          zip: {
                                                                                                                                                                                                                                                                              <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>;
                                                                                                                                                                                                                                                                              <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>;
                                                                                                                                                                                                                                                                              <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>;
                                                                                                                                                                                                                                                                              <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>;
                                                                                                                                                                                                                                                                              <T>(this, ...sources): AsyncIterable<T[]>;
                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T2

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T3

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                this: AsyncIterable<T>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Returns AsyncIterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T2

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T3

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T4

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                this: AsyncIterable<T>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Returns AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T2

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T3

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T4

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T5

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                this: AsyncIterable<T>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Returns AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T2

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T3

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T4

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T5

                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T6

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                this: AsyncIterable<T>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                source6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • <T>(this, ...sources): AsyncIterable<T[]>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                T

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                this: AsyncIterable<T>
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                Rest ...sources: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Returns AsyncIterable<T[]>

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Methods

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Abstract [asyncIterator]

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                          • [asyncIterator](signal?): AsyncIterator<T, any, undefined>
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              Optional signal: AbortSignal
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterator<T, any, undefined>

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          forEach

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              projection: ((value, index, signal?) => void | Promise<void>)
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                • (value, index, signal?): void | Promise<void>
                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                    value: T
                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                    index: number
                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                    Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                  Returns void | Promise<void>

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              Optional thisArg: any
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              Optional signal: AbortSignal
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns Promise<void>

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Nocollapse

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          pipe

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              R

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              Rest ...operations: UnaryFunction<AsyncIterable<T>, R>[]
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns R

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Nocollapse

                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              R

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              Rest ...operations: OperatorAsyncFunction<T, R>[]
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<R>

                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              R extends WritableStream

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              writable: R
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              Optional options: {
                                                                                                                                                                                                                                                                                  end?: boolean;
                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                Optional end?: boolean
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns R

                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              A

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op1: OperatorAsyncFunction<T, A>
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<A>

                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              A

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              B

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op1: OperatorAsyncFunction<T, A>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op2: OperatorAsyncFunction<A, B>
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<B>

                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              A

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              B

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              C

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op1: OperatorAsyncFunction<T, A>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op2: OperatorAsyncFunction<A, B>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op3: OperatorAsyncFunction<B, C>
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<C>

                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              A

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              B

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              C

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              D

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op1: OperatorAsyncFunction<T, A>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op2: OperatorAsyncFunction<A, B>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op3: OperatorAsyncFunction<B, C>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op4: OperatorAsyncFunction<C, D>
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<D>

                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              A

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              B

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              C

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              D

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              E

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op1: OperatorAsyncFunction<T, A>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op2: OperatorAsyncFunction<A, B>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op3: OperatorAsyncFunction<B, C>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op4: OperatorAsyncFunction<C, D>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op5: OperatorAsyncFunction<D, E>
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<E>

                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              A

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              B

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              C

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              D

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              E

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              F

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op1: OperatorAsyncFunction<T, A>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op2: OperatorAsyncFunction<A, B>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op3: OperatorAsyncFunction<B, C>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op4: OperatorAsyncFunction<C, D>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op5: OperatorAsyncFunction<D, E>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op6: OperatorAsyncFunction<E, F>
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<F>

                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              A

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              B

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              C

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              D

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              E

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              F

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              G

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op1: OperatorAsyncFunction<T, A>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op2: OperatorAsyncFunction<A, B>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op3: OperatorAsyncFunction<B, C>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op4: OperatorAsyncFunction<C, D>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op5: OperatorAsyncFunction<D, E>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op6: OperatorAsyncFunction<E, F>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op7: OperatorAsyncFunction<F, G>
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<G>

                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              A

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              B

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              C

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              D

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              E

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              F

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              G

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              H

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op1: OperatorAsyncFunction<T, A>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op2: OperatorAsyncFunction<A, B>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op3: OperatorAsyncFunction<B, C>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op4: OperatorAsyncFunction<C, D>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op5: OperatorAsyncFunction<D, E>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op6: OperatorAsyncFunction<E, F>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op7: OperatorAsyncFunction<F, G>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op8: OperatorAsyncFunction<G, H>
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<H>

                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              A

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              B

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              C

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              D

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              E

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              F

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              G

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              H

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              I

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op1: OperatorAsyncFunction<T, A>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op2: OperatorAsyncFunction<A, B>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op3: OperatorAsyncFunction<B, C>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op4: OperatorAsyncFunction<C, D>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op5: OperatorAsyncFunction<D, E>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op6: OperatorAsyncFunction<E, F>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op7: OperatorAsyncFunction<F, G>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op8: OperatorAsyncFunction<G, H>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op9: OperatorAsyncFunction<H, I>
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<I>

                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              Rest ...operations: OperatorAsyncFunction<any, any>[]
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<any>

                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              A extends WritableStream

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              op1: A
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              Optional options: {
                                                                                                                                                                                                                                                                                  end?: boolean;
                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                Optional end?: boolean
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns A

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          pipeThrough

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              R extends ReadableStream<any>

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              duplex: {
                                                                                                                                                                                                                                                                                  readable: R;
                                                                                                                                                                                                                                                                                  writable: WritableStream<T>;
                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                readable: R
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                writable: WritableStream<T>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              Optional options: StreamPipeOptions
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns R

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          pipeTo

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              writable: WritableStream<T>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              Optional options: StreamPipeOptions
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns Promise<void>

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          tee

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Static as

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                                                            Converts an existing string into an async-iterable of characters.

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              source: string
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              The string to convert to an async-iterable.

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<string>

                                                                                                                                                                                                                                                                            An async-iterable stream of characters from the source.

                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                                                            Converts the AsyncIterable-like input or single element into an AsyncIterable.

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              T

                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              The type of elements in the async-iterable like sequence.

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              source: T | AsyncIterableInput<T>
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              The async-iterable like input to convert to an async-iterable.

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                            An async-iterable stream from elements in the async-iterable like sequence.

                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                                                            Converts the single element into an async-iterable sequence.

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              T

                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              The type of the input to turn into an async-iterable sequence.

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              source: T
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              The single element to turn into an async-iterable sequence.

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                            An async-iterable sequence which contains the single element.

                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Static from

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              TSource

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                              TResult = TSource

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              source: AsyncIterableInput<TSource>
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              selector: ((value, index) => TResult | Promise<TResult>) = identityAsync
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                • (value, index): TResult | Promise<TResult>
                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                    value: TSource
                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                    index: number
                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                  Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                              Optional thisArg: any
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Nocollapse

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Member Visibility

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Theme

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          On This Page

                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Generated using TypeDoc

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          \ No newline at end of file diff --git a/docs/classes/Ix.Iterable-1.html b/docs/classes/Ix.Iterable-1.html index 1369f825..e608e9e4 100644 --- a/docs/classes/Ix.Iterable-1.html +++ b/docs/classes/Ix.Iterable-1.html @@ -1,6 +1,141 @@ -Iterable | IxJS

                                                                                                                                                                                                                                                                          Class Iterable<T>Abstract

                                                                                                                                                                                                                                                                          This class serves as the base for all operations which support [Symbol.iterator].

                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                          • T

                                                                                                                                                                                                                                                                          Hierarchy

                                                                                                                                                                                                                                                                          • Iterable<T>
                                                                                                                                                                                                                                                                            • Iterable

                                                                                                                                                                                                                                                                          Implements

                                                                                                                                                                                                                                                                          • Iterable<T>

                                                                                                                                                                                                                                                                          Constructors

                                                                                                                                                                                                                                                                          constructor -

                                                                                                                                                                                                                                                                          Properties

                                                                                                                                                                                                                                                                          average +Iterable | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                          Class Iterable<T>Abstract

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          This class serves as the base for all operations which support [Symbol.iterator].

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                                                            T

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Hierarchy

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                          • Iterable<T> +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • Iterable
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Implements

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                          • Iterable<T>
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Constructors

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          constructor +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Properties

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          average buffer catchError concat @@ -70,7 +205,10 @@ toSet union zip -

                                                                                                                                                                                                                                                                          Methods

                                                                                                                                                                                                                                                                          [iterator] +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Methods

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          [iterator] forEach pipe pipeThrough @@ -78,19 +216,2162 @@ tee as from -

                                                                                                                                                                                                                                                                          Constructors

                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                          Properties

                                                                                                                                                                                                                                                                          average

                                                                                                                                                                                                                                                                          average: {
                                                                                                                                                                                                                                                                              (this, options?): number;
                                                                                                                                                                                                                                                                              <T>(this, options?): number;
                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                            • (this, options?): number

                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                              • this: Iterable<number>
                                                                                                                                                                                                                                                                              • Optional options: MathOptions<number>

                                                                                                                                                                                                                                                                              Returns number

                                                                                                                                                                                                                                                                            • <T>(this, options?): number

                                                                                                                                                                                                                                                                            • Type Parameters

                                                                                                                                                                                                                                                                              • T

                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                              • this: Iterable<T>
                                                                                                                                                                                                                                                                              • Optional options: MathOptions<T>

                                                                                                                                                                                                                                                                              Returns number

                                                                                                                                                                                                                                                                          buffer

                                                                                                                                                                                                                                                                          buffer: {}

                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                            catchError

                                                                                                                                                                                                                                                                            catchError: {}

                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                              concat

                                                                                                                                                                                                                                                                              concat: (<T, T2, T3>(this, v2, v3) => Iterable<T | T2 | T3>)

                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                • <T, T2, T3>(this, v2, v3): Iterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                • Type Parameters

                                                                                                                                                                                                                                                                                  • T

                                                                                                                                                                                                                                                                                  • T2

                                                                                                                                                                                                                                                                                  • T3

                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                  • this: Iterable<T>
                                                                                                                                                                                                                                                                                  • v2: Iterable<T2>
                                                                                                                                                                                                                                                                                  • v3: Iterable<T3>

                                                                                                                                                                                                                                                                                  Returns Iterable<T | T2 | T3>

                                                                                                                                                                                                                                                                              concatAll

                                                                                                                                                                                                                                                                              concatAll: {}

                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                count

                                                                                                                                                                                                                                                                                count: {}

                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                  defaultIfEmpty

                                                                                                                                                                                                                                                                                  defaultIfEmpty: {}

                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                    distinct

                                                                                                                                                                                                                                                                                    distinct: {}

                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                      distinctUntilChanged

                                                                                                                                                                                                                                                                                      distinctUntilChanged: {}

                                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                                        doWhile

                                                                                                                                                                                                                                                                                        doWhile: {}

                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                          elementAt

                                                                                                                                                                                                                                                                                          elementAt: {}

                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                            endWith

                                                                                                                                                                                                                                                                                            endWith: {}

                                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                                              every

                                                                                                                                                                                                                                                                                              every: {}

                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                except

                                                                                                                                                                                                                                                                                                except: {}

                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                  expand

                                                                                                                                                                                                                                                                                                  expand: {}

                                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                                    filter

                                                                                                                                                                                                                                                                                                    filter: (<T>(this, predicate, thisArg?) => Iterable<T>)

                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                      • <T>(this, predicate, thisArg?): Iterable<T>

                                                                                                                                                                                                                                                                                                      • Type Parameters

                                                                                                                                                                                                                                                                                                        • T

                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                        • this: Iterable<T>
                                                                                                                                                                                                                                                                                                        • predicate: ((value, index) => boolean)
                                                                                                                                                                                                                                                                                                            • (value, index): boolean

                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                              • value: T
                                                                                                                                                                                                                                                                                                              • index: number

                                                                                                                                                                                                                                                                                                              Returns boolean

                                                                                                                                                                                                                                                                                                        • Optional thisArg: any

                                                                                                                                                                                                                                                                                                        Returns Iterable<T>

                                                                                                                                                                                                                                                                                                    finally

                                                                                                                                                                                                                                                                                                    finally: {}

                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                      find

                                                                                                                                                                                                                                                                                                      find: {}

                                                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                                                        findIndex

                                                                                                                                                                                                                                                                                                        findIndex: {}

                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                          first

                                                                                                                                                                                                                                                                                                          first: {}

                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                            flat

                                                                                                                                                                                                                                                                                                            flat: {}

                                                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                                                              flatMap

                                                                                                                                                                                                                                                                                                              flatMap: {}

                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                groupBy

                                                                                                                                                                                                                                                                                                                groupBy: {
                                                                                                                                                                                                                                                                                                                    <TSource, TKey>(this, keySelector): Iterable<GroupedIterable<TKey, TSource>>;
                                                                                                                                                                                                                                                                                                                    <TSource, TKey, TValue>(this, keySelector, elementSelector?): Iterable<GroupedIterable<TKey, TValue>>;
                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                  • <TSource, TKey>(this, keySelector): Iterable<GroupedIterable<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                    • this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                    • keySelector: ((value) => TKey)
                                                                                                                                                                                                                                                                                                                        • (value): TKey

                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                          • value: TSource

                                                                                                                                                                                                                                                                                                                          Returns TKey

                                                                                                                                                                                                                                                                                                                    Returns Iterable<GroupedIterable<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                  • <TSource, TKey, TValue>(this, keySelector, elementSelector?): Iterable<GroupedIterable<TKey, TValue>>

                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                    • TValue

                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                    • this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                    • keySelector: ((value) => TKey)
                                                                                                                                                                                                                                                                                                                        • (value): TKey

                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                          • value: TSource

                                                                                                                                                                                                                                                                                                                          Returns TKey

                                                                                                                                                                                                                                                                                                                    • Optional elementSelector: ((value) => TValue)
                                                                                                                                                                                                                                                                                                                        • (value): TValue

                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                          • value: TSource

                                                                                                                                                                                                                                                                                                                          Returns TValue

                                                                                                                                                                                                                                                                                                                    Returns Iterable<GroupedIterable<TKey, TValue>>

                                                                                                                                                                                                                                                                                                                groupJoin

                                                                                                                                                                                                                                                                                                                groupJoin: {}

                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                  ignoreElements

                                                                                                                                                                                                                                                                                                                  ignoreElements: {}

                                                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                                                    includes

                                                                                                                                                                                                                                                                                                                    includes: {}

                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                      innerJoin

                                                                                                                                                                                                                                                                                                                      innerJoin: {}

                                                                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                                                                        intersect

                                                                                                                                                                                                                                                                                                                        intersect: {}

                                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                                          isEmpty

                                                                                                                                                                                                                                                                                                                          isEmpty: {}

                                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                                            last

                                                                                                                                                                                                                                                                                                                            last: {}

                                                                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                                                                              map

                                                                                                                                                                                                                                                                                                                              map: {}

                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                max

                                                                                                                                                                                                                                                                                                                                max: (<TSource, TResult>(this, options?) => TResult)

                                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                                  • <TSource, TResult>(this, options?): TResult

                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                    • TResult = TSource

                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                    • this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                    • Optional options: ExtremaOptions<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                    Returns TResult

                                                                                                                                                                                                                                                                                                                                maxBy

                                                                                                                                                                                                                                                                                                                                maxBy: {}

                                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                                  memoize

                                                                                                                                                                                                                                                                                                                                  memoize: {
                                                                                                                                                                                                                                                                                                                                      <TSource>(this, readerCount?): Iterable<TSource>;
                                                                                                                                                                                                                                                                                                                                      <TSource, TResult>(this, readerCount?, selector?): Iterable<TResult>;
                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                                                                    • <TSource>(this, readerCount?): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                    • Type Parameters

                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                      • this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                      • Optional readerCount: number

                                                                                                                                                                                                                                                                                                                                      Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                    • <TSource, TResult>(this, readerCount?, selector?): Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                    • Type Parameters

                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                      • TResult

                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                      • this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                      • Optional readerCount: number
                                                                                                                                                                                                                                                                                                                                      • Optional selector: ((value) => Iterable<TResult>)
                                                                                                                                                                                                                                                                                                                                          • (value): Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                            • value: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                            Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                      Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                  min

                                                                                                                                                                                                                                                                                                                                  min: {}

                                                                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                                                                    minBy

                                                                                                                                                                                                                                                                                                                                    minBy: {}

                                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                                      onErrorResumeNext

                                                                                                                                                                                                                                                                                                                                      onErrorResumeNext: {}

                                                                                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                                                                                        orderBy

                                                                                                                                                                                                                                                                                                                                        orderBy: {}

                                                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                                                          orderByDescending

                                                                                                                                                                                                                                                                                                                                          orderByDescending: {}

                                                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                                                            pairwise

                                                                                                                                                                                                                                                                                                                                            pairwise: {}

                                                                                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                                                                                              pluck

                                                                                                                                                                                                                                                                                                                                              pluck: {}

                                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                                publish

                                                                                                                                                                                                                                                                                                                                                publish: {
                                                                                                                                                                                                                                                                                                                                                    <T>(this): Iterable<T>;
                                                                                                                                                                                                                                                                                                                                                    <T, R>(this, selector?): Iterable<R>;
                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                                                  • <T>(this): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                  • <T, R>(this, selector?): Iterable<R>

                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                    • R

                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                    • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                    • Optional selector: ((value) => Iterable<R>)
                                                                                                                                                                                                                                                                                                                                                        • (value): Iterable<R>

                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                          • value: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                          Returns Iterable<R>

                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<R>

                                                                                                                                                                                                                                                                                                                                                reduce

                                                                                                                                                                                                                                                                                                                                                reduce: (<T, R>(this, accumulator, seed?) => R)

                                                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                                                  • <T, R>(this, accumulator, seed?): R

                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                    • R = T

                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                    • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                    • accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                        • (accumulator, current, index): R

                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                          • accumulator: R
                                                                                                                                                                                                                                                                                                                                                          • current: T
                                                                                                                                                                                                                                                                                                                                                          • index: number

                                                                                                                                                                                                                                                                                                                                                          Returns R

                                                                                                                                                                                                                                                                                                                                                    • Optional seed: R

                                                                                                                                                                                                                                                                                                                                                    Returns R

                                                                                                                                                                                                                                                                                                                                                reduceRight

                                                                                                                                                                                                                                                                                                                                                reduceRight: (<T, R>(this, accumulator, seed?) => R)

                                                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                                                  • <T, R>(this, accumulator, seed?): R

                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                    • R = T

                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                    • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                    • accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                        • (accumulator, current, index): R

                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                          • accumulator: R
                                                                                                                                                                                                                                                                                                                                                          • current: T
                                                                                                                                                                                                                                                                                                                                                          • index: number

                                                                                                                                                                                                                                                                                                                                                          Returns R

                                                                                                                                                                                                                                                                                                                                                    • Optional seed: R

                                                                                                                                                                                                                                                                                                                                                    Returns R

                                                                                                                                                                                                                                                                                                                                                repeat

                                                                                                                                                                                                                                                                                                                                                repeat: {}

                                                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                                                  retry

                                                                                                                                                                                                                                                                                                                                                  retry: {}

                                                                                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                                                                                    reverse

                                                                                                                                                                                                                                                                                                                                                    reverse: {}

                                                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                                                      scan

                                                                                                                                                                                                                                                                                                                                                      scan: (<T, R>(this, accumulator, seed?) => Iterable<R>)

                                                                                                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                                                                                                        • <T, R>(this, accumulator, seed?): Iterable<R>

                                                                                                                                                                                                                                                                                                                                                        • Type Parameters

                                                                                                                                                                                                                                                                                                                                                          • T

                                                                                                                                                                                                                                                                                                                                                          • R = T

                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                          • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                          • accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                              • (accumulator, current, index): R

                                                                                                                                                                                                                                                                                                                                                              • Parameters

                                                                                                                                                                                                                                                                                                                                                                • accumulator: R
                                                                                                                                                                                                                                                                                                                                                                • current: T
                                                                                                                                                                                                                                                                                                                                                                • index: number

                                                                                                                                                                                                                                                                                                                                                                Returns R

                                                                                                                                                                                                                                                                                                                                                          • Optional seed: R

                                                                                                                                                                                                                                                                                                                                                          Returns Iterable<R>

                                                                                                                                                                                                                                                                                                                                                      scanRight

                                                                                                                                                                                                                                                                                                                                                      scanRight: (<T, R>(this, accumulator, seed?) => Iterable<R>)

                                                                                                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                                                                                                        • <T, R>(this, accumulator, seed?): Iterable<R>

                                                                                                                                                                                                                                                                                                                                                        • Type Parameters

                                                                                                                                                                                                                                                                                                                                                          • T

                                                                                                                                                                                                                                                                                                                                                          • R = T

                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                          • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                          • accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                              • (accumulator, current, index): R

                                                                                                                                                                                                                                                                                                                                                              • Parameters

                                                                                                                                                                                                                                                                                                                                                                • accumulator: R
                                                                                                                                                                                                                                                                                                                                                                • current: T
                                                                                                                                                                                                                                                                                                                                                                • index: number

                                                                                                                                                                                                                                                                                                                                                                Returns R

                                                                                                                                                                                                                                                                                                                                                          • Optional seed: R

                                                                                                                                                                                                                                                                                                                                                          Returns Iterable<R>

                                                                                                                                                                                                                                                                                                                                                      sequenceEqual

                                                                                                                                                                                                                                                                                                                                                      sequenceEqual: {}

                                                                                                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                                                                                                        share

                                                                                                                                                                                                                                                                                                                                                        share: {
                                                                                                                                                                                                                                                                                                                                                            <TSource>(this): Iterable<TSource>;
                                                                                                                                                                                                                                                                                                                                                            <TSource, TResult>(this, fn?): Iterable<TResult>;
                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                                                                          • <TSource>(this): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                          • Type Parameters

                                                                                                                                                                                                                                                                                                                                                            • TSource

                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                            Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                          • <TSource, TResult>(this, fn?): Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                          • Type Parameters

                                                                                                                                                                                                                                                                                                                                                            • TSource

                                                                                                                                                                                                                                                                                                                                                            • TResult

                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                            • this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                            • Optional fn: ((value) => Iterable<TResult>)
                                                                                                                                                                                                                                                                                                                                                                • (value): Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                • Parameters

                                                                                                                                                                                                                                                                                                                                                                  • value: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                  Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                            Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                        single

                                                                                                                                                                                                                                                                                                                                                        single: {}

                                                                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                                                                          skip

                                                                                                                                                                                                                                                                                                                                                          skip: {}

                                                                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                                                                            skipLast

                                                                                                                                                                                                                                                                                                                                                            skipLast: {}

                                                                                                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                                                                                                              skipWhile

                                                                                                                                                                                                                                                                                                                                                              skipWhile: (<T>(this, predicate) => Iterable<T>)

                                                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                                                • <T>(this, predicate): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                  • T

                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                  • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                  • predicate: ((value, index) => boolean)
                                                                                                                                                                                                                                                                                                                                                                      • (value, index): boolean

                                                                                                                                                                                                                                                                                                                                                                      • Parameters

                                                                                                                                                                                                                                                                                                                                                                        • value: T
                                                                                                                                                                                                                                                                                                                                                                        • index: number

                                                                                                                                                                                                                                                                                                                                                                        Returns boolean

                                                                                                                                                                                                                                                                                                                                                                  Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                              slice

                                                                                                                                                                                                                                                                                                                                                              slice: {}

                                                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                                                some

                                                                                                                                                                                                                                                                                                                                                                some: {}

                                                                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                                                                  startWith

                                                                                                                                                                                                                                                                                                                                                                  startWith: {}

                                                                                                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                                                                                                    sum

                                                                                                                                                                                                                                                                                                                                                                    sum: {
                                                                                                                                                                                                                                                                                                                                                                        (this, options?): number;
                                                                                                                                                                                                                                                                                                                                                                        <T>(this, options?): number;
                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                                                                      • (this, options?): number

                                                                                                                                                                                                                                                                                                                                                                      • Parameters

                                                                                                                                                                                                                                                                                                                                                                        • this: Iterable<number>
                                                                                                                                                                                                                                                                                                                                                                        • Optional options: MathOptions<number>

                                                                                                                                                                                                                                                                                                                                                                        Returns number

                                                                                                                                                                                                                                                                                                                                                                      • <T>(this, options?): number

                                                                                                                                                                                                                                                                                                                                                                      • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                        • T

                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                        • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                        • Optional options: MathOptions<T>

                                                                                                                                                                                                                                                                                                                                                                        Returns number

                                                                                                                                                                                                                                                                                                                                                                    take

                                                                                                                                                                                                                                                                                                                                                                    take: {}

                                                                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                                                                      takeLast

                                                                                                                                                                                                                                                                                                                                                                      takeLast: {}

                                                                                                                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                                                                                                                        takeWhile

                                                                                                                                                                                                                                                                                                                                                                        takeWhile: (<T>(this, predicate) => Iterable<T>)

                                                                                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                                                                                          • <T>(this, predicate): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                          • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                            • T

                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                            • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                            • predicate: ((value, index) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                • (value, index): boolean

                                                                                                                                                                                                                                                                                                                                                                                • Parameters

                                                                                                                                                                                                                                                                                                                                                                                  • value: T
                                                                                                                                                                                                                                                                                                                                                                                  • index: number

                                                                                                                                                                                                                                                                                                                                                                                  Returns boolean

                                                                                                                                                                                                                                                                                                                                                                            Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                        tap

                                                                                                                                                                                                                                                                                                                                                                        tap: (<TSource>(this, next?, error?, complete?) => Iterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                                                                                          • <TSource>(this, next?, error?, complete?): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                          • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                            • TSource

                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                            • this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                            • Optional next: null | ((value) => any)
                                                                                                                                                                                                                                                                                                                                                                            • Optional error: null | ((err) => any)
                                                                                                                                                                                                                                                                                                                                                                            • Optional complete: null | (() => any)

                                                                                                                                                                                                                                                                                                                                                                            Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                        toArray

                                                                                                                                                                                                                                                                                                                                                                        toArray: {}

                                                                                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                                                                                          toDOMStream

                                                                                                                                                                                                                                                                                                                                                                          toDOMStream: {
                                                                                                                                                                                                                                                                                                                                                                              <T>(this, options): ReadableStream<Uint8Array>;
                                                                                                                                                                                                                                                                                                                                                                              <T>(this, options): ReadableStream<Uint8Array>;
                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                                                                                            • <T>(this, options): ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                            • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                              • T

                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                              • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                              • options: ReadableBYOBStreamOptions<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                              Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                            • <T>(this, options): ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                            • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                              • T

                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                              • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                              • options: ReadableByteStreamOptions<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                              Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                          toMap

                                                                                                                                                                                                                                                                                                                                                                          toMap: (<TSource, TKey, TElement>(this, options) => Map<TKey, TElement | TSource>)

                                                                                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                                                                                            • <TSource, TKey, TElement>(this, options): Map<TKey, TElement | TSource>

                                                                                                                                                                                                                                                                                                                                                                            • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                              • TSource

                                                                                                                                                                                                                                                                                                                                                                              • TKey

                                                                                                                                                                                                                                                                                                                                                                              • TElement = TSource

                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                              • this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                              • options: ToMapOptions<TSource, TKey, TElement>

                                                                                                                                                                                                                                                                                                                                                                              Returns Map<TKey, TElement | TSource>

                                                                                                                                                                                                                                                                                                                                                                          toNodeStream

                                                                                                                                                                                                                                                                                                                                                                          toNodeStream: {
                                                                                                                                                                                                                                                                                                                                                                              <TSource>(this, options): IterableReadable<TSource>;
                                                                                                                                                                                                                                                                                                                                                                              <TSource>(this, options): IterableReadable<TSource>;
                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                                                                                            • <TSource>(this, options): IterableReadable<TSource>

                                                                                                                                                                                                                                                                                                                                                                            • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                              • TSource

                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                              • this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                              • options: ReadableOptions | {
                                                                                                                                                                                                                                                                                                                                                                                    objectMode: true;
                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                              Returns IterableReadable<TSource>

                                                                                                                                                                                                                                                                                                                                                                            • <TSource>(this, options): IterableReadable<TSource>

                                                                                                                                                                                                                                                                                                                                                                            • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                              • TSource extends BufferLike

                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                              • this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                              • options: ReadableOptions | {
                                                                                                                                                                                                                                                                                                                                                                                    objectMode: false;
                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                              Returns IterableReadable<TSource>

                                                                                                                                                                                                                                                                                                                                                                          toSet

                                                                                                                                                                                                                                                                                                                                                                          toSet: {}

                                                                                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                                                                                            union

                                                                                                                                                                                                                                                                                                                                                                            union: {}

                                                                                                                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                                                                                                                              zip

                                                                                                                                                                                                                                                                                                                                                                              zip: {
                                                                                                                                                                                                                                                                                                                                                                                  <T, T2, T3>(this, source2, source3): Iterable<[T, T2, T3]>;
                                                                                                                                                                                                                                                                                                                                                                                  <T, T2, T3, T4>(this, source2, source3, source4): Iterable<[T, T2, T3, T4]>;
                                                                                                                                                                                                                                                                                                                                                                                  <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): Iterable<[T, T2, T3, T4, T5]>;
                                                                                                                                                                                                                                                                                                                                                                                  <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): Iterable<[T, T2, T3, T4, T5, T6]>;
                                                                                                                                                                                                                                                                                                                                                                                  <T>(this, ...sources): Iterable<T[]>;
                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                                                                • <T, T2, T3>(this, source2, source3): Iterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                  • T

                                                                                                                                                                                                                                                                                                                                                                                  • T2

                                                                                                                                                                                                                                                                                                                                                                                  • T3

                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                  • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                  • source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                  • source3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                  Returns Iterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                • <T, T2, T3, T4>(this, source2, source3, source4): Iterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                  • T

                                                                                                                                                                                                                                                                                                                                                                                  • T2

                                                                                                                                                                                                                                                                                                                                                                                  • T3

                                                                                                                                                                                                                                                                                                                                                                                  • T4

                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                  • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                  • source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                  • source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                  • source4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                  Returns Iterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                • <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): Iterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                  • T

                                                                                                                                                                                                                                                                                                                                                                                  • T2

                                                                                                                                                                                                                                                                                                                                                                                  • T3

                                                                                                                                                                                                                                                                                                                                                                                  • T4

                                                                                                                                                                                                                                                                                                                                                                                  • T5

                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                  • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                  • source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                  • source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                  • source4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                  • source5: Iterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                  Returns Iterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                • <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): Iterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                  • T

                                                                                                                                                                                                                                                                                                                                                                                  • T2

                                                                                                                                                                                                                                                                                                                                                                                  • T3

                                                                                                                                                                                                                                                                                                                                                                                  • T4

                                                                                                                                                                                                                                                                                                                                                                                  • T5

                                                                                                                                                                                                                                                                                                                                                                                  • T6

                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                  • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                  • source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                  • source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                  • source4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                  • source5: Iterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                  • source6: Iterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                  Returns Iterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                • <T>(this, ...sources): Iterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                  • T

                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                  • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                  • Rest ...sources: Iterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                  Returns Iterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                              Methods

                                                                                                                                                                                                                                                                                                                                                                              Abstract [iterator]

                                                                                                                                                                                                                                                                                                                                                                              • [iterator](): Iterator<T, any, undefined>

                                                                                                                                                                                                                                                                                                                                                                              • Returns Iterator<T, any, undefined>

                                                                                                                                                                                                                                                                                                                                                                              forEach

                                                                                                                                                                                                                                                                                                                                                                              • forEach(projection, thisArg?): void

                                                                                                                                                                                                                                                                                                                                                                              • Parameters

                                                                                                                                                                                                                                                                                                                                                                                • projection: ((value, index) => void)
                                                                                                                                                                                                                                                                                                                                                                                    • (value, index): void

                                                                                                                                                                                                                                                                                                                                                                                    • Parameters

                                                                                                                                                                                                                                                                                                                                                                                      • value: T
                                                                                                                                                                                                                                                                                                                                                                                      • index: number

                                                                                                                                                                                                                                                                                                                                                                                      Returns void

                                                                                                                                                                                                                                                                                                                                                                                • Optional thisArg: any

                                                                                                                                                                                                                                                                                                                                                                                Returns void

                                                                                                                                                                                                                                                                                                                                                                                Nocollapse

                                                                                                                                                                                                                                                                                                                                                                              pipe

                                                                                                                                                                                                                                                                                                                                                                              • pipe<R>(...operations): R

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • R

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • Rest ...operations: UnaryFunction<Iterable<T>, R>[]

                                                                                                                                                                                                                                                                                                                                                                                Returns R

                                                                                                                                                                                                                                                                                                                                                                                Nocollapse

                                                                                                                                                                                                                                                                                                                                                                              • pipe<R>(...operations): Iterable<R>

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • R

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • Rest ...operations: OperatorFunction<T, R>[]

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<R>

                                                                                                                                                                                                                                                                                                                                                                              • pipe<R>(writable, options?): R

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • R extends WritableStream

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • writable: R
                                                                                                                                                                                                                                                                                                                                                                                • Optional options: {
                                                                                                                                                                                                                                                                                                                                                                                      end?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                  • Optional end?: boolean

                                                                                                                                                                                                                                                                                                                                                                                Returns R

                                                                                                                                                                                                                                                                                                                                                                              • pipe(): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                              • Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                              • pipe<A>(op1): Iterable<A>

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • A

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • op1: OperatorFunction<T, A>

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<A>

                                                                                                                                                                                                                                                                                                                                                                              • pipe<A, B>(op1, op2): Iterable<B>

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • A

                                                                                                                                                                                                                                                                                                                                                                                • B

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                • op2: OperatorFunction<A, B>

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<B>

                                                                                                                                                                                                                                                                                                                                                                              • pipe<A, B, C>(op1, op2, op3): Iterable<C>

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • A

                                                                                                                                                                                                                                                                                                                                                                                • B

                                                                                                                                                                                                                                                                                                                                                                                • C

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                • op2: OperatorFunction<A, B>
                                                                                                                                                                                                                                                                                                                                                                                • op3: OperatorFunction<B, C>

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<C>

                                                                                                                                                                                                                                                                                                                                                                              • pipe<A, B, C, D>(op1, op2, op3, op4): Iterable<D>

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • A

                                                                                                                                                                                                                                                                                                                                                                                • B

                                                                                                                                                                                                                                                                                                                                                                                • C

                                                                                                                                                                                                                                                                                                                                                                                • D

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                • op2: OperatorFunction<A, B>
                                                                                                                                                                                                                                                                                                                                                                                • op3: OperatorFunction<B, C>
                                                                                                                                                                                                                                                                                                                                                                                • op4: OperatorFunction<C, D>

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<D>

                                                                                                                                                                                                                                                                                                                                                                              • pipe<A, B, C, D, E>(op1, op2, op3, op4, op5): Iterable<E>

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • A

                                                                                                                                                                                                                                                                                                                                                                                • B

                                                                                                                                                                                                                                                                                                                                                                                • C

                                                                                                                                                                                                                                                                                                                                                                                • D

                                                                                                                                                                                                                                                                                                                                                                                • E

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                • op2: OperatorFunction<A, B>
                                                                                                                                                                                                                                                                                                                                                                                • op3: OperatorFunction<B, C>
                                                                                                                                                                                                                                                                                                                                                                                • op4: OperatorFunction<C, D>
                                                                                                                                                                                                                                                                                                                                                                                • op5: OperatorFunction<D, E>

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<E>

                                                                                                                                                                                                                                                                                                                                                                              • pipe<A, B, C, D, E, F>(op1, op2, op3, op4, op5, op6): Iterable<F>

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • A

                                                                                                                                                                                                                                                                                                                                                                                • B

                                                                                                                                                                                                                                                                                                                                                                                • C

                                                                                                                                                                                                                                                                                                                                                                                • D

                                                                                                                                                                                                                                                                                                                                                                                • E

                                                                                                                                                                                                                                                                                                                                                                                • F

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                • op2: OperatorFunction<A, B>
                                                                                                                                                                                                                                                                                                                                                                                • op3: OperatorFunction<B, C>
                                                                                                                                                                                                                                                                                                                                                                                • op4: OperatorFunction<C, D>
                                                                                                                                                                                                                                                                                                                                                                                • op5: OperatorFunction<D, E>
                                                                                                                                                                                                                                                                                                                                                                                • op6: OperatorFunction<E, F>

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<F>

                                                                                                                                                                                                                                                                                                                                                                              • pipe<A, B, C, D, E, F, G>(op1, op2, op3, op4, op5, op6, op7): Iterable<G>

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • A

                                                                                                                                                                                                                                                                                                                                                                                • B

                                                                                                                                                                                                                                                                                                                                                                                • C

                                                                                                                                                                                                                                                                                                                                                                                • D

                                                                                                                                                                                                                                                                                                                                                                                • E

                                                                                                                                                                                                                                                                                                                                                                                • F

                                                                                                                                                                                                                                                                                                                                                                                • G

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                • op2: OperatorFunction<A, B>
                                                                                                                                                                                                                                                                                                                                                                                • op3: OperatorFunction<B, C>
                                                                                                                                                                                                                                                                                                                                                                                • op4: OperatorFunction<C, D>
                                                                                                                                                                                                                                                                                                                                                                                • op5: OperatorFunction<D, E>
                                                                                                                                                                                                                                                                                                                                                                                • op6: OperatorFunction<E, F>
                                                                                                                                                                                                                                                                                                                                                                                • op7: OperatorFunction<F, G>

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<G>

                                                                                                                                                                                                                                                                                                                                                                              • pipe<A, B, C, D, E, F, G, H>(op1, op2, op3, op4, op5, op6, op7, op8): Iterable<H>

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • A

                                                                                                                                                                                                                                                                                                                                                                                • B

                                                                                                                                                                                                                                                                                                                                                                                • C

                                                                                                                                                                                                                                                                                                                                                                                • D

                                                                                                                                                                                                                                                                                                                                                                                • E

                                                                                                                                                                                                                                                                                                                                                                                • F

                                                                                                                                                                                                                                                                                                                                                                                • G

                                                                                                                                                                                                                                                                                                                                                                                • H

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                • op2: OperatorFunction<A, B>
                                                                                                                                                                                                                                                                                                                                                                                • op3: OperatorFunction<B, C>
                                                                                                                                                                                                                                                                                                                                                                                • op4: OperatorFunction<C, D>
                                                                                                                                                                                                                                                                                                                                                                                • op5: OperatorFunction<D, E>
                                                                                                                                                                                                                                                                                                                                                                                • op6: OperatorFunction<E, F>
                                                                                                                                                                                                                                                                                                                                                                                • op7: OperatorFunction<F, G>
                                                                                                                                                                                                                                                                                                                                                                                • op8: OperatorFunction<G, H>

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<H>

                                                                                                                                                                                                                                                                                                                                                                              • pipe<A, B, C, D, E, F, G, H, I>(op1, op2, op3, op4, op5, op6, op7, op8, op9): Iterable<I>

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • A

                                                                                                                                                                                                                                                                                                                                                                                • B

                                                                                                                                                                                                                                                                                                                                                                                • C

                                                                                                                                                                                                                                                                                                                                                                                • D

                                                                                                                                                                                                                                                                                                                                                                                • E

                                                                                                                                                                                                                                                                                                                                                                                • F

                                                                                                                                                                                                                                                                                                                                                                                • G

                                                                                                                                                                                                                                                                                                                                                                                • H

                                                                                                                                                                                                                                                                                                                                                                                • I

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                • op2: OperatorFunction<A, B>
                                                                                                                                                                                                                                                                                                                                                                                • op3: OperatorFunction<B, C>
                                                                                                                                                                                                                                                                                                                                                                                • op4: OperatorFunction<C, D>
                                                                                                                                                                                                                                                                                                                                                                                • op5: OperatorFunction<D, E>
                                                                                                                                                                                                                                                                                                                                                                                • op6: OperatorFunction<E, F>
                                                                                                                                                                                                                                                                                                                                                                                • op7: OperatorFunction<F, G>
                                                                                                                                                                                                                                                                                                                                                                                • op8: OperatorFunction<G, H>
                                                                                                                                                                                                                                                                                                                                                                                • op9: OperatorFunction<H, I>

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<I>

                                                                                                                                                                                                                                                                                                                                                                              • pipe<R>(...operations): Iterable<R>

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • R

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • Rest ...operations: OperatorFunction<T, R>[]

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<R>

                                                                                                                                                                                                                                                                                                                                                                              • pipe<A>(op1, options?): A

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • A extends WritableStream

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • op1: A
                                                                                                                                                                                                                                                                                                                                                                                • Optional options: {
                                                                                                                                                                                                                                                                                                                                                                                      end?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                  • Optional end?: boolean

                                                                                                                                                                                                                                                                                                                                                                                Returns A

                                                                                                                                                                                                                                                                                                                                                                              pipeThrough

                                                                                                                                                                                                                                                                                                                                                                              • pipeThrough<R>(duplex, options?): R

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • R extends ReadableStream<any>

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • duplex: {
                                                                                                                                                                                                                                                                                                                                                                                      readable: R;
                                                                                                                                                                                                                                                                                                                                                                                      writable: WritableStream<T>;
                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                  • readable: R
                                                                                                                                                                                                                                                                                                                                                                                  • writable: WritableStream<T>
                                                                                                                                                                                                                                                                                                                                                                                • Optional options: StreamPipeOptions

                                                                                                                                                                                                                                                                                                                                                                                Returns R

                                                                                                                                                                                                                                                                                                                                                                              pipeTo

                                                                                                                                                                                                                                                                                                                                                                              • pipeTo(writable, options?): Promise<void>

                                                                                                                                                                                                                                                                                                                                                                              • Parameters

                                                                                                                                                                                                                                                                                                                                                                                • writable: WritableStream<T>
                                                                                                                                                                                                                                                                                                                                                                                • Optional options: StreamPipeOptions

                                                                                                                                                                                                                                                                                                                                                                                Returns Promise<void>

                                                                                                                                                                                                                                                                                                                                                                              tee

                                                                                                                                                                                                                                                                                                                                                                              Static as

                                                                                                                                                                                                                                                                                                                                                                              • as(source): Iterable<string>

                                                                                                                                                                                                                                                                                                                                                                              • Converts an existing string into an iterable of characters.

                                                                                                                                                                                                                                                                                                                                                                                -

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • source: string

                                                                                                                                                                                                                                                                                                                                                                                  The string to convert to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<string>

                                                                                                                                                                                                                                                                                                                                                                                An terable stream of characters from the source.

                                                                                                                                                                                                                                                                                                                                                                                -
                                                                                                                                                                                                                                                                                                                                                                              • as<T>(source): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                              • Converts the iterable like input into an iterable.

                                                                                                                                                                                                                                                                                                                                                                                -

                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • T

                                                                                                                                                                                                                                                                                                                                                                                  The tyep of elements in the source iterable.

                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                  The iterable to convert to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                An iterable stream of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                -
                                                                                                                                                                                                                                                                                                                                                                              • as<T>(source): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                              • Converts an array-like object to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                -

                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • T

                                                                                                                                                                                                                                                                                                                                                                                  The type of elements in the source array-like sequence.

                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • source: ArrayLike<T>

                                                                                                                                                                                                                                                                                                                                                                                  The array-like sequence to convert to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                The iterable containing the elements from the array-like sequence.

                                                                                                                                                                                                                                                                                                                                                                                -
                                                                                                                                                                                                                                                                                                                                                                              • as<T>(source): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                              • Converts the object into a singleton in an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                -

                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • T

                                                                                                                                                                                                                                                                                                                                                                                  The type of element to turn into an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • source: T

                                                                                                                                                                                                                                                                                                                                                                                  The item to turn into an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                An iterable sequence from the source object.

                                                                                                                                                                                                                                                                                                                                                                                -

                                                                                                                                                                                                                                                                                                                                                                              Static from

                                                                                                                                                                                                                                                                                                                                                                              • from<TSource, TResult>(source, selector?, thisArg?): Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                              • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                • TSource

                                                                                                                                                                                                                                                                                                                                                                                • TResult = TSource

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                • source: Iterable<TSource> | Iterator<TSource, any, undefined> | ArrayLike<TSource>
                                                                                                                                                                                                                                                                                                                                                                                • selector: ((value, index) => TResult) = identity
                                                                                                                                                                                                                                                                                                                                                                                    • (value, index): TResult

                                                                                                                                                                                                                                                                                                                                                                                    • Parameters

                                                                                                                                                                                                                                                                                                                                                                                      • value: TSource
                                                                                                                                                                                                                                                                                                                                                                                      • index: number

                                                                                                                                                                                                                                                                                                                                                                                      Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                • Optional thisArg: any

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                Nocollapse

                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                              Member Visibility

                                                                                                                                                                                                                                                                                                                                                                              Theme

                                                                                                                                                                                                                                                                                                                                                                              On This Page

                                                                                                                                                                                                                                                                                                                                                                              \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              Constructors

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                • +

                                                                                                                                                                                                                                                                                                                                                                                  T

                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              Properties

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              average

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              average: {
                                                                                                                                                                                                                                                                                                                                                                                  (this, options?): number;
                                                                                                                                                                                                                                                                                                                                                                                  <T>(this, options?): number;
                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                • (this, options?): number
                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                    this: Iterable<number>
                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                    Optional options: MathOptions<number>
                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                  Returns number

                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                • <T>(this, options?): number
                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                    this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                    Optional options: MathOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                  Returns number

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              buffer

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              buffer: {}
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                catchError

                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                catchError: {}
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                  concat

                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  concat: (<T, T2, T3>(this, v2, v3) => Iterable<T | T2 | T3>)
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                    • <T, T2, T3>(this, v2, v3): Iterable<T | T2 | T3>
                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                        this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                        v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                        v3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                  concatAll

                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  concatAll: {}
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                    count

                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    count: {}
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                      defaultIfEmpty

                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      defaultIfEmpty: {}
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                        distinct

                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        distinct: {}
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                          distinctUntilChanged

                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          distinctUntilChanged: {}
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                            doWhile

                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            doWhile: {}
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                              elementAt

                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              elementAt: {}
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                endWith

                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                endWith: {}
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                  every

                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  every: {}
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                    except

                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    except: {}
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                      expand

                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      expand: {}
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                        filter

                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        filter: (<T>(this, predicate, thisArg?) => Iterable<T>)
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                          • <T>(this, predicate, thisArg?): Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                                                                                                                                                              T

                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                              this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                              predicate: ((value, index) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                • (value, index): boolean
                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                    value: T
                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                    index: number
                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                  Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                              Optional thisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                            Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                        finally

                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        finally: {}
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                          find

                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          find: {}
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                            findIndex

                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            findIndex: {}
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                              first

                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              first: {}
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                flat

                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                flat: {}
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                  flatMap

                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  flatMap: {}
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                    groupBy

                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    groupBy: {
                                                                                                                                                                                                                                                                                                                                                                                                                        <TSource, TKey>(this, keySelector): Iterable<GroupedIterable<TKey, TSource>>;
                                                                                                                                                                                                                                                                                                                                                                                                                        <TSource, TKey, TValue>(this, keySelector, elementSelector?): Iterable<GroupedIterable<TKey, TValue>>;
                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                      • <TSource, TKey>(this, keySelector): Iterable<GroupedIterable<TKey, TSource>>
                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                          TKey

                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                          this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                          keySelector: ((value) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Iterable<GroupedIterable<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                      • <TSource, TKey, TValue>(this, keySelector, elementSelector?): Iterable<GroupedIterable<TKey, TValue>>
                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                          TKey

                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                          TValue

                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                          this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                          keySelector: ((value) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                          Optional elementSelector: ((value) => TValue)
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): TValue
                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TValue

                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Iterable<GroupedIterable<TKey, TValue>>

                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                    groupJoin

                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    groupJoin: {}
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreElements

                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreElements: {}
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                        includes

                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        includes: {}
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                          innerJoin

                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          innerJoin: {}
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                            intersect

                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            intersect: {}
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                              isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              isEmpty: {}
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                last

                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                last: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                  map

                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  map: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                    max

                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    max: (<TSource, TResult>(this, options?) => TResult)
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                      • <TSource, TResult>(this, options?): TResult
                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                          TResult = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                          this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional options: ExtremaOptions<TSource, TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                    maxBy

                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    maxBy: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                      memoize

                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      memoize: {
                                                                                                                                                                                                                                                                                                                                                                                                                                          <TSource>(this, readerCount?): Iterable<TSource>;
                                                                                                                                                                                                                                                                                                                                                                                                                                          <TSource, TResult>(this, readerCount?, selector?): Iterable<TResult>;
                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                        • <TSource>(this, readerCount?): Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                                                                                                                                                                                                                            TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                            this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional readerCount: number
                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                        • <TSource, TResult>(this, readerCount?, selector?): Iterable<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                                                                                                                                                                                                                            TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                                                                                                                                                                                                                            TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                            this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional readerCount: number
                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional selector: ((value) => Iterable<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                              • (value): Iterable<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                      min

                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      min: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                        minBy

                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        minBy: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                          onErrorResumeNext

                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          onErrorResumeNext: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                            orderBy

                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            orderBy: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                              orderByDescending

                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              orderByDescending: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                pairwise

                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                pairwise: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                  pluck

                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  pluck: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                    publish

                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    publish: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        <T>(this): Iterable<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        <T, R>(this, selector?): Iterable<R>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • <T>(this): Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          T

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • <T, R>(this, selector?): Iterable<R>
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          T

                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          R

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional selector: ((value) => Iterable<R>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): Iterable<R>
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns Iterable<R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Iterable<R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                    reduce

                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    reduce: (<T, R>(this, accumulator, seed?) => R)
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • <T, R>(this, accumulator, seed?): R
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          T

                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (accumulator, current, index): R
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                accumulator: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                current: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional seed: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                    reduceRight

                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    reduceRight: (<T, R>(this, accumulator, seed?) => R)
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • <T, R>(this, accumulator, seed?): R
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          T

                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (accumulator, current, index): R
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                accumulator: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                current: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional seed: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                    repeat

                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    repeat: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                      retry

                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      retry: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        reverse: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          scan

                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          scan: (<T, R>(this, accumulator, seed?) => Iterable<R>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • <T, R>(this, accumulator, seed?): Iterable<R>
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • (accumulator, current, index): R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      accumulator: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      current: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional seed: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns Iterable<R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          scanRight

                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          scanRight: (<T, R>(this, accumulator, seed?) => Iterable<R>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • <T, R>(this, accumulator, seed?): Iterable<R>
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • (accumulator, current, index): R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      accumulator: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      current: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional seed: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns Iterable<R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          sequenceEqual

                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          sequenceEqual: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                            share

                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            share: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                <TSource>(this): Iterable<TSource>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                <TSource, TResult>(this, fn?): Iterable<TResult>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • <TSource>(this): Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • <TSource, TResult>(this, fn?): Iterable<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Optional fn: ((value) => Iterable<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • (value): Iterable<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                            single

                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            single: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              skip: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                skipLast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                skipLast: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  skipWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  skipWhile: (<T>(this, predicate) => Iterable<T>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • <T>(this, predicate): Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        predicate: ((value, index) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, index): boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  slice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  slice: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    some

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    some: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      startWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      startWith: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sum: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (this, options?): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T>(this, options?): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (this, options?): number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              this: Iterable<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional options: MathOptions<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • <T>(this, options?): number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional options: MathOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        take

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        take: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          takeLast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          takeLast: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            takeWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            takeWhile: (<T>(this, predicate) => Iterable<T>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • <T>(this, predicate): Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  predicate: ((value, index) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • (value, index): boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tap: (<TSource>(this, next?, error?, complete?) => Iterable<TSource>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • <TSource>(this, next?, error?, complete?): Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Optional next: null | ((value) => any)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Optional error: null | ((err) => any)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Optional complete: null | (() => any)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            toArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            toArray: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toDOMStream: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <T>(this, options): ReadableStream<Uint8Array>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <T>(this, options): ReadableStream<Uint8Array>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • <T>(this, options): ReadableStream<Uint8Array>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options: ReadableBYOBStreamOptions<Uint8Array>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • <T>(this, options): ReadableStream<Uint8Array>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options: ReadableByteStreamOptions<Uint8Array>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toMap: (<TSource, TKey, TElement>(this, options) => Map<TKey, TElement | TSource>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • <TSource, TKey, TElement>(this, options): Map<TKey, TElement | TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TElement = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options: ToMapOptions<TSource, TKey, TElement>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns Map<TKey, TElement | TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toNodeStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toNodeStream: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <TSource>(this, options): IterableReadable<TSource>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <TSource>(this, options): IterableReadable<TSource>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • <TSource>(this, options): IterableReadable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options: ReadableOptions | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        objectMode: true;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns IterableReadable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • <TSource>(this, options): IterableReadable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TSource extends BufferLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options: ReadableOptions | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        objectMode: false;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns IterableReadable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toSet: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                union

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                union: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  zip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  zip: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <T, T2, T3>(this, source2, source3): Iterable<[T, T2, T3]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <T, T2, T3, T4>(this, source2, source3, source4): Iterable<[T, T2, T3, T4]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): Iterable<[T, T2, T3, T4, T5]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): Iterable<[T, T2, T3, T4, T5, T6]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <T>(this, ...sources): Iterable<T[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • <T, T2, T3>(this, source2, source3): Iterable<[T, T2, T3]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • <T, T2, T3, T4>(this, source2, source3, source4): Iterable<[T, T2, T3, T4]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): Iterable<[T, T2, T3, T4, T5]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source5: Iterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): Iterable<[T, T2, T3, T4, T5, T6]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source5: Iterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source6: Iterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • <T>(this, ...sources): Iterable<T[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Rest ...sources: Iterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Methods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Abstract [iterator]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • [iterator](): Iterator<T, any, undefined>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterator<T, any, undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  forEach

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projection: ((value, index) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional thisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nocollapse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pipe

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...operations: UnaryFunction<Iterable<T>, R>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nocollapse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...operations: OperatorFunction<T, R>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R extends WritableStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      writable: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          end?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional end?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<A>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      B

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op2: OperatorFunction<A, B>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<B>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      B

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      C

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op2: OperatorFunction<A, B>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op3: OperatorFunction<B, C>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<C>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      B

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      C

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      D

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op2: OperatorFunction<A, B>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op3: OperatorFunction<B, C>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op4: OperatorFunction<C, D>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<D>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      B

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      C

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      D

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      E

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op2: OperatorFunction<A, B>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op3: OperatorFunction<B, C>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op4: OperatorFunction<C, D>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op5: OperatorFunction<D, E>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<E>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      B

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      C

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      D

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      E

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      F

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op2: OperatorFunction<A, B>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op3: OperatorFunction<B, C>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op4: OperatorFunction<C, D>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op5: OperatorFunction<D, E>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op6: OperatorFunction<E, F>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<F>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      B

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      C

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      D

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      E

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      F

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      G

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op2: OperatorFunction<A, B>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op3: OperatorFunction<B, C>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op4: OperatorFunction<C, D>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op5: OperatorFunction<D, E>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op6: OperatorFunction<E, F>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op7: OperatorFunction<F, G>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<G>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      B

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      C

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      D

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      E

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      F

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      G

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      H

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op2: OperatorFunction<A, B>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op3: OperatorFunction<B, C>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op4: OperatorFunction<C, D>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op5: OperatorFunction<D, E>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op6: OperatorFunction<E, F>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op7: OperatorFunction<F, G>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op8: OperatorFunction<G, H>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<H>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      B

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      C

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      D

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      E

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      F

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      G

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      H

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      I

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op1: OperatorFunction<T, A>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op2: OperatorFunction<A, B>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op3: OperatorFunction<B, C>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op4: OperatorFunction<C, D>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op5: OperatorFunction<D, E>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op6: OperatorFunction<E, F>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op7: OperatorFunction<F, G>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op8: OperatorFunction<G, H>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op9: OperatorFunction<H, I>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<I>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...operations: OperatorFunction<T, R>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A extends WritableStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      op1: A
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          end?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional end?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns A

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pipeThrough

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R extends ReadableStream<any>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      duplex: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readable: R;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          writable: WritableStream<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readable: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        writable: WritableStream<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: StreamPipeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pipeTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      writable: WritableStream<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: StreamPipeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<void>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tee

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns [ReadableStream<T>, ReadableStream<T>]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Static as

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an existing string into an iterable of characters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The string to convert to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<string>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An terable stream of characters from the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts the iterable like input into an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The tyep of elements in the source iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The iterable to convert to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable stream of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an array-like object to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source array-like sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: ArrayLike<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The array-like sequence to convert to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The iterable containing the elements from the array-like sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts the object into a singleton in an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of element to turn into an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The item to turn into an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence from the source object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Static from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TResult = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<TSource> | Iterator<TSource, any, undefined> | ArrayLike<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selector: ((value, index) => TResult) = identity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index): TResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional thisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nocollapse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.asyncify.html b/docs/functions/Ix.AsyncIterable.asyncify.html index b7c441fd..6ad7b20d 100644 --- a/docs/functions/Ix.AsyncIterable.asyncify.html +++ b/docs/functions/Ix.AsyncIterable.asyncify.html @@ -1,5 +1,130 @@ -asyncify | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function asyncify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • asyncify<TSource>(func): ((...args) => AsyncIterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts the callback function into wrapped function which returns an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the value returned from the callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • func: ((...xs) => any)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The callback function to wrap as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...xs): any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Rest ...xs: any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ((...args) => AsyncIterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A function when invoked, returns an async-iterable from the callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +asyncify | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function asyncify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts the callback function into wrapped function which returns an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the value returned from the callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func: ((...xs) => any)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The callback function to wrap as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...xs): any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Rest ...xs: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ((...args) => AsyncIterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A function when invoked, returns an async-iterable from the callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.asyncifyErrback.html b/docs/functions/Ix.AsyncIterable.asyncifyErrback.html index 565cda0f..72c95968 100644 --- a/docs/functions/Ix.AsyncIterable.asyncifyErrback.html +++ b/docs/functions/Ix.AsyncIterable.asyncifyErrback.html @@ -1,5 +1,130 @@ -asyncifyErrback | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function asyncifyErrback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • asyncifyErrback<TSource>(func): ((...args) => AsyncIterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts a Node.js style error first callback to an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the returned value from the callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • func: ((...xs) => any)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Node.js error first callback to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...xs): any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Rest ...xs: any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ((...args) => AsyncIterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A function, when invoked, contains the result of the callback as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +asyncifyErrback | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function asyncifyErrback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts a Node.js style error first callback to an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the returned value from the callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func: ((...xs) => any)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Node.js error first callback to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...xs): any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Rest ...xs: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ((...args) => AsyncIterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A function, when invoked, contains the result of the callback as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.catchAll.html b/docs/functions/Ix.AsyncIterable.catchAll.html index bc97ca04..778f1f6a 100644 --- a/docs/functions/Ix.AsyncIterable.catchAll.html +++ b/docs/functions/Ix.AsyncIterable.catchAll.html @@ -1,6 +1,109 @@ -catchAll | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function catchAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • catchAll<T>(source): AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Continues an async-iterable sequence that is terminated by an exception with the next async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source and handler sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<AsyncIterable<T>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      async-iterable sequences to catch exceptions for.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence containing elements from consecutive source +catchAll | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function catchAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Continues an async-iterable sequence that is terminated by an exception with the next async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source and handler sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: Iterable<AsyncIterable<T>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        async-iterable sequences to catch exceptions for.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing elements from consecutive source sequences until a source sequence terminates successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.catchError.html b/docs/functions/Ix.AsyncIterable.catchError.html index bf55c959..40b8930f 100644 --- a/docs/functions/Ix.AsyncIterable.catchError.html +++ b/docs/functions/Ix.AsyncIterable.catchError.html @@ -1,6 +1,109 @@ -catchError | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function catchError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • catchError<T>(...args): AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Continues an async-iterable sequence that is terminated by an exception with the next async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source and handler sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...args: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      async-iterable sequences to catch exceptions for.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence containing elements from consecutive source +catchError | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function catchError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Continues an async-iterable sequence that is terminated by an exception with the next async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source and handler sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Rest ...args: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        async-iterable sequences to catch exceptions for.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing elements from consecutive source sequences until a source sequence terminates successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.combineLatest.html b/docs/functions/Ix.AsyncIterable.combineLatest.html index 27072d69..ca15b47d 100644 --- a/docs/functions/Ix.AsyncIterable.combineLatest.html +++ b/docs/functions/Ix.AsyncIterable.combineLatest.html @@ -1,61 +1,389 @@ -combineLatest | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function combineLatest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • combineLatest<T, T2>(source, source2): AsyncIterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +combineLatest | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function combineLatest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • combineLatest<T, T2, T3>(source, source2, source3): AsyncIterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • combineLatest<T, T2, T3, T4>(source, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • combineLatest<T, T2, T3, T4, T5>(source, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • combineLatest<T, T2, T3, T4, T5, T6>(source, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • combineLatest<T>(...sources): AsyncIterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Rest ...sources: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The async-iterable sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.concat.html b/docs/functions/Ix.AsyncIterable.concat.html index af154306..da636ecc 100644 --- a/docs/functions/Ix.AsyncIterable.concat.html +++ b/docs/functions/Ix.AsyncIterable.concat.html @@ -1,58 +1,365 @@ -concat | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function concat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concat<T, T2>(v1, v2): AsyncIterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates the second async-iterable sequence to the first async-iterable sequence upon successful termination of the first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v1: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains the elements of the first sequence, +concat | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function concat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates the second async-iterable sequence to the first async-iterable sequence upon successful termination of the first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v1: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements of the first sequence, followed by those of the second the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • concat<T, T2, T3>(v1, v2, v3): AsyncIterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v1: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • concat<T, T2, T3, T4>(v1, v2, v3, v4): AsyncIterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v1: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v1: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • concat<T, T2, T3, T4, T5>(v1, v2, v3, v4, v5): AsyncIterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v1: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v1: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements of each +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v1: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concat<T, T2, T3, T4, T5, T6>(v1, v2, v3, v4, v5, v6): AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v1: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains the elements of each +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v1: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.create.html b/docs/functions/Ix.AsyncIterable.create.html index 9328f3f4..d1608f3b 100644 --- a/docs/functions/Ix.AsyncIterable.create.html +++ b/docs/functions/Ix.AsyncIterable.create.html @@ -1,5 +1,119 @@ -create | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • create<T>(fn): AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates a new iterable using the specified function implementing the members of AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements returned by the enumerable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • fn: ((signal?) => AsyncIterator<T, any, undefined> | Promise<AsyncIterator<T, any, undefined>>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The function that creates the Symbol.asyncIterator method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (signal?): AsyncIterator<T, any, undefined> | Promise<AsyncIterator<T, any, undefined>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns AsyncIterator<T, any, undefined> | Promise<AsyncIterator<T, any, undefined>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A new async-iterable instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +create | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates a new iterable using the specified function implementing the members of AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements returned by the enumerable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fn: ((signal?) => AsyncIterator<T, any, undefined> | Promise<AsyncIterator<T, any, undefined>>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The function that creates the Symbol.asyncIterator method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (signal?): AsyncIterator<T, any, undefined> | Promise<AsyncIterator<T, any, undefined>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns AsyncIterator<T, any, undefined> | Promise<AsyncIterator<T, any, undefined>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A new async-iterable instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.defer.html b/docs/functions/Ix.AsyncIterable.defer.html index a5a7d97d..2e97f95f 100644 --- a/docs/functions/Ix.AsyncIterable.defer.html +++ b/docs/functions/Ix.AsyncIterable.defer.html @@ -1,6 +1,120 @@ -defer | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function defer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • defer<TSource>(factory): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns an async-iterable sequence that invokes the specified factory function whenever a call to [Symbol.asyncIterator] has been made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sequence returned by the factory function, and in the resulting sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • factory: ((signal?) => AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async-iterable factory function to +defer | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function defer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns an async-iterable sequence that invokes the specified factory function whenever a call to [Symbol.asyncIterator] has been made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the sequence returned by the factory function, and in the resulting sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          factory: ((signal?) => AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Async-iterable factory function to invoke for each call to [Symbol.asyncIterator].

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (signal?): AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An async-iterable sequence whose observers trigger an invocation of the given async-iterable factory function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (signal?): AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence whose observers trigger an invocation of the given async-iterable factory function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.empty.html b/docs/functions/Ix.AsyncIterable.empty.html index 8950c2e1..4fb98fba 100644 --- a/docs/functions/Ix.AsyncIterable.empty.html +++ b/docs/functions/Ix.AsyncIterable.empty.html @@ -1,3 +1,92 @@ -empty | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +empty | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.forkJoin.html b/docs/functions/Ix.AsyncIterable.forkJoin.html index 65c580af..4c7ad83e 100644 --- a/docs/functions/Ix.AsyncIterable.forkJoin.html +++ b/docs/functions/Ix.AsyncIterable.forkJoin.html @@ -1,120 +1,743 @@ -forkJoin | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function forkJoin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2>(source, source2): Promise<[T, T2] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3>(source, source2, source3): Promise<[T, T2, T3] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3, T4>(source, source2, source3, source4): Promise<[T, T2, T3, T4] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3, T4, T5>(source, source2, source3, source4, source5): Promise<[T, T2, T3, T4, T5] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3, T4, T5, T6>(source, source2, source3, source4, source5, source6): Promise<[T, T2, T3, T4, T5, T6] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5, T6] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T>(signal, source): Promise<[T] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2>(signal, source, source2): Promise<[T, T2] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3>(signal, source, source2, source3): Promise<[T, T2, T3] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3, T4>(signal, source, source2, source3, source4): Promise<[T, T2, T3, T4] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3, T4, T5>(signal, source, source2, source3, source4, source5): Promise<[T, T2, T3, T4, T5] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3, T4, T5, T6>(signal, source, source2, source3, source4, source5, source6): Promise<[T, T2, T3, T4, T5, T6] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5, T6] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T>(...sources): Promise<T[] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...sources: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<T[] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T>(signal, ...sources): Promise<T[] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...sources: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<T[] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +forkJoin | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function forkJoin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5, T6] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5, T6] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<T[] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<T[] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.fromDOMStream.html b/docs/functions/Ix.AsyncIterable.fromDOMStream.html index c5d3b255..cc243415 100644 --- a/docs/functions/Ix.AsyncIterable.fromDOMStream.html +++ b/docs/functions/Ix.AsyncIterable.fromDOMStream.html @@ -1,10 +1,141 @@ -fromDOMStream | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fromDOMStream<TSource>(stream): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates an async-iterable from an existing DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • stream: ReadableStream<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The DOM Readable stream to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable containing the elements from the ReadableStream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fromDOMStream<TSource>(stream, options): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates an async-iterable from an existing DOM stream and options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource extends ArrayBufferView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • stream: ReadableStream<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The readable stream to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mode: "byob";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options to set the mode for the DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mode: "byob"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable created from the incoming async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +fromDOMStream | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates an async-iterable from an existing DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stream: ReadableStream<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The DOM Readable stream to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable containing the elements from the ReadableStream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates an async-iterable from an existing DOM stream and options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource extends ArrayBufferView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stream: ReadableStream<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The readable stream to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mode: "byob";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options to set the mode for the DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mode: "byob"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable created from the incoming async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.fromEvent.html b/docs/functions/Ix.AsyncIterable.fromEvent.html index 892c92ee..4a51203c 100644 --- a/docs/functions/Ix.AsyncIterable.fromEvent.html +++ b/docs/functions/Ix.AsyncIterable.fromEvent.html @@ -1 +1,181 @@ -fromEvent | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +fromEvent | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      obj: EventedTarget
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      eventName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      obj: EventedTarget
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      eventName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resultSelector: ((...args) => TSource)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...args): TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Rest ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      obj: EventedTarget
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      eventName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: EventListenerOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      obj: EventedTarget
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      eventName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: EventListenerOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resultSelector: ((...args) => TSource)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...args): TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Rest ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.fromEventPattern.html b/docs/functions/Ix.AsyncIterable.fromEventPattern.html index 917deb1d..6d24c3ad 100644 --- a/docs/functions/Ix.AsyncIterable.fromEventPattern.html +++ b/docs/functions/Ix.AsyncIterable.fromEventPattern.html @@ -1,6 +1,170 @@ -fromEventPattern | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromEventPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fromEventPattern<TSource>(addHandler, removeHandler, resultSelector?): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates async-iterable from an event emitter by adding handlers for both listening and unsubscribing from events.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the event emitter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • addHandler: ((handler) => void)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The function to add a listener to the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (handler): void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • handler: ((...args) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • (...args): void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Rest ...args: any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • removeHandler: ((handler) => void)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The function to remove a listener from the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (handler): void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • handler: ((...args) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • (...args): void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Rest ...args: any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional resultSelector: ((...args) => TSource)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...args): TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Rest ...args: any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable which contains the data from the underlying events as wrapped by the handlers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +fromEventPattern | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromEventPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates async-iterable from an event emitter by adding handlers for both listening and unsubscribing from events.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the event emitter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      addHandler: ((handler) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The function to add a listener to the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (handler): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handler: ((...args) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • (...args): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Rest ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      removeHandler: ((handler) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The function to remove a listener from the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (handler): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handler: ((...args) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • (...args): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Rest ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional resultSelector: ((...args) => TSource)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...args): TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Rest ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable which contains the data from the underlying events as wrapped by the handlers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.fromNodeStream.html b/docs/functions/Ix.AsyncIterable.fromNodeStream.html index 0d37f2a6..fb080f41 100644 --- a/docs/functions/Ix.AsyncIterable.fromNodeStream.html +++ b/docs/functions/Ix.AsyncIterable.fromNodeStream.html @@ -1,5 +1,105 @@ -fromNodeStream | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromNodeStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fromNodeStream(stream, size?): AsyncIterable<string | Buffer>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates a new async-iterable from a Node.js stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • stream: ReadableStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Node.js stream to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional size: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The size of the buffers for the stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<string | Buffer>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable containing data from the stream either in string or Buffer format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +fromNodeStream | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromNodeStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates a new async-iterable from a Node.js stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stream: ReadableStream
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Node.js stream to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional size: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The size of the buffers for the stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<string | Buffer>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable containing data from the stream either in string or Buffer format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.generate.html b/docs/functions/Ix.AsyncIterable.generate.html index 941523a1..bf2d6342 100644 --- a/docs/functions/Ix.AsyncIterable.generate.html +++ b/docs/functions/Ix.AsyncIterable.generate.html @@ -1,10 +1,168 @@ -generate | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function generate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • generate<TState, TResult>(initialState, condition, iterate, resultSelector): AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Generates an async-iterable sequence by running a state-driven loop producing the sequence's elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the state used in the generator loop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the produced sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • initialState: TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The initial state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • condition: ((value, signal?) => boolean | Promise<boolean>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Condition to terminate generation (upon returning false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • iterate: ((value, signal?) => TState | Promise<TState>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Iteration step function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): TState | Promise<TState>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TState | Promise<TState>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • resultSelector: ((value, signal?) => TResult | Promise<TResult>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Selector function for results produced in +generate | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function generate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Generates an async-iterable sequence by running a state-driven loop producing the sequence's elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the state used in the generator loop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the produced sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          initialState: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The initial state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          condition: ((value, signal?) => boolean | Promise<boolean>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Condition to terminate generation (upon returning false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): boolean | Promise<boolean>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          iterate: ((value, signal?) => TState | Promise<TState>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Iteration step function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TState | Promise<TState>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TState | Promise<TState>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resultSelector: ((value, signal?) => TResult | Promise<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Selector function for results produced in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The generated async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): TResult | Promise<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The generated async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.generateTime.html b/docs/functions/Ix.AsyncIterable.generateTime.html index 2740cea6..175eb1d5 100644 --- a/docs/functions/Ix.AsyncIterable.generateTime.html +++ b/docs/functions/Ix.AsyncIterable.generateTime.html @@ -1,11 +1,186 @@ -generateTime | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function generateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • generateTime<TState, TResult>(initialState, condition, iterate, resultSelector, timeSelector): AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Generates an async-iterable sequence by running a time-based state-driven loop producing the sequence's elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the state used in the generator loop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the produced sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • initialState: TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The initial state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • condition: ((value, signal?) => boolean | Promise<boolean>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Condition to terminate generation (upon returning false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • iterate: ((value, signal?) => TState | Promise<TState>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Iteration step function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): TState | Promise<TState>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TState | Promise<TState>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • resultSelector: ((value, signal?) => TResult | Promise<TResult>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Selector function for results produced in +generateTime | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function generateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Generates an async-iterable sequence by running a time-based state-driven loop producing the sequence's elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the state used in the generator loop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the produced sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          initialState: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The initial state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          condition: ((value, signal?) => boolean | Promise<boolean>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Condition to terminate generation (upon returning false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): boolean | Promise<boolean>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          iterate: ((value, signal?) => TState | Promise<TState>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Iteration step function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TState | Promise<TState>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TState | Promise<TState>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resultSelector: ((value, signal?) => TResult | Promise<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Selector function for results produced in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • timeSelector: ((value, signal?) => number | Promise<number>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Selector function for how much time to wait.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): number | Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns number | Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The generated async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): TResult | Promise<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      timeSelector: ((value, signal?) => number | Promise<number>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Selector function for how much time to wait.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): number | Promise<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns number | Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The generated async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.iif.html b/docs/functions/Ix.AsyncIterable.iif.html index f35c560f..2524d963 100644 --- a/docs/functions/Ix.AsyncIterable.iif.html +++ b/docs/functions/Ix.AsyncIterable.iif.html @@ -1,8 +1,130 @@ -iif | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function iif

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • iif<TSource>(condition, thenSource, elseSource?): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • If the specified condition evaluates true, select the thenSource sequence. +iif | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function iif

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If the specified condition evaluates true, select the thenSource sequence. Otherwise, select the elseSource sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • condition: ((signal?) => boolean | Promise<boolean>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Condition evaluated to decide which sequence to return.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (signal?): boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • thenSource: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sequence returned in case evaluates true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional elseSource: AsyncIterable<TSource> = ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sequence returned in case condition evaluates false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      thenSource if condition evaluates true; elseSource otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      condition: ((signal?) => boolean | Promise<boolean>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Condition evaluated to decide which sequence to return.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (signal?): boolean | Promise<boolean>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      thenSource: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sequence returned in case evaluates true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional elseSource: AsyncIterable<TSource> = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sequence returned in case condition evaluates false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    thenSource if condition evaluates true; elseSource otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.merge.html b/docs/functions/Ix.AsyncIterable.merge.html index 8e6bb9e9..06d5d5f4 100644 --- a/docs/functions/Ix.AsyncIterable.merge.html +++ b/docs/functions/Ix.AsyncIterable.merge.html @@ -1,60 +1,392 @@ -merge | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function merge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • merge<T, T2>(source, v2): AsyncIterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • merge<T, T2, T3>(source, v2, v3): AsyncIterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The merged elements from all of the specified async-iterable sequences +merge | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function merge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • merge<T, T2, T3, T4>(source, v2, v3, v4): AsyncIterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • merge<T, T2, T3, T4, T5>(source, v2, v3, v4, v5): AsyncIterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • merge<T, T2, T3, T4, T5, T6>(source, v2, v3, v4, v5, v6): AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The sixth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The sixth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • merge<T>(source, ...args): AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the sequence to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Rest ...args: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The async-iterable sources to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sequence to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...args: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable sources to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.never.html b/docs/functions/Ix.AsyncIterable.never.html index bf2de276..d537d3f9 100644 --- a/docs/functions/Ix.AsyncIterable.never.html +++ b/docs/functions/Ix.AsyncIterable.never.html @@ -1,3 +1,92 @@ -never | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function never

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +never | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function never

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.of.html b/docs/functions/Ix.AsyncIterable.of.html index c4e70ede..721ffaab 100644 --- a/docs/functions/Ix.AsyncIterable.of.html +++ b/docs/functions/Ix.AsyncIterable.of.html @@ -1,5 +1,108 @@ -of | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function of

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • of<TSource>(...args): AsyncIterable<TSource[number & keyof TSource]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates an async-iterable from the specified elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource extends any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements to create an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...args: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The elements to turn into an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource[number & keyof TSource]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The async-iterable sequence created from the elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +of | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function of

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates an async-iterable from the specified elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource extends any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements to create an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...args: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The elements to turn into an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource[number & keyof TSource]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The async-iterable sequence created from the elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.onErrorResumeNext.html b/docs/functions/Ix.AsyncIterable.onErrorResumeNext.html index 85881acb..e265f880 100644 --- a/docs/functions/Ix.AsyncIterable.onErrorResumeNext.html +++ b/docs/functions/Ix.AsyncIterable.onErrorResumeNext.html @@ -1,5 +1,108 @@ -onErrorResumeNext | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function onErrorResumeNext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • onErrorResumeNext<T>(...args): AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates all of the specified async-iterable sequences, even if the previous async-iterable sequence terminated exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...args: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async-iterable sequences to concatenate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that concatenates the source sequences, even if a sequence terminates exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +onErrorResumeNext | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function onErrorResumeNext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Concatenates all of the specified async-iterable sequences, even if the previous async-iterable sequence terminated exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...args: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async-iterable sequences to concatenate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that concatenates the source sequences, even if a sequence terminates exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.race.html b/docs/functions/Ix.AsyncIterable.race.html index 6630ec03..05c7a244 100644 --- a/docs/functions/Ix.AsyncIterable.race.html +++ b/docs/functions/Ix.AsyncIterable.race.html @@ -1,4 +1,105 @@ -race | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function race

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • race<TSource>(...sources): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Propagates the async sequence that reacts first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...sources: AsyncIterable<TSource>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async sequence that surfaces either of the given sequences, whichever reacted first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +race | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function race

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Propagates the async sequence that reacts first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: AsyncIterable<TSource>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async sequence that surfaces either of the given sequences, whichever reacted first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.range.html b/docs/functions/Ix.AsyncIterable.range.html index 88bd1553..be8a445f 100644 --- a/docs/functions/Ix.AsyncIterable.range.html +++ b/docs/functions/Ix.AsyncIterable.range.html @@ -1,5 +1,105 @@ -range | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • range(start, count): AsyncIterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Generates an async-iterable sequence of integral numbers within a specified range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • start: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value of the first integer in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • count: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of sequential integers to generate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains a range of sequential integral numbers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +range | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Generates an async-iterable sequence of integral numbers within a specified range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      start: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value of the first integer in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of sequential integers to generate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains a range of sequential integral numbers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.repeatValue.html b/docs/functions/Ix.AsyncIterable.repeatValue.html index e9641d72..b4e496df 100644 --- a/docs/functions/Ix.AsyncIterable.repeatValue.html +++ b/docs/functions/Ix.AsyncIterable.repeatValue.html @@ -1,6 +1,113 @@ -repeatValue | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function repeatValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repeatValue<TSource>(value, count?): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Repeats a given value for the specified number of times as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of element to repeat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • value: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to repeat as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional count: number = -1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of times to repeat the value, infinite if not specified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable with a single item that is repeated over the specified times.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +repeatValue | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function repeatValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Repeats a given value for the specified number of times as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of element to repeat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to repeat as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional count: number = -1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of times to repeat the value, infinite if not specified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable with a single item that is repeated over the specified times.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.throwError.html b/docs/functions/Ix.AsyncIterable.throwError.html index a705adff..d77f9c7f 100644 --- a/docs/functions/Ix.AsyncIterable.throwError.html +++ b/docs/functions/Ix.AsyncIterable.throwError.html @@ -1,4 +1,100 @@ -throwError | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function throwError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • throwError(error): AsyncIterable<never>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates an async-iterable that throws the specified error upon iterating.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • error: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The error to throw upon iterating the async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<never>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable that throws when iterated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +throwError | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function throwError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates an async-iterable that throws the specified error upon iterating.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      error: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The error to throw upon iterating the async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<never>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable that throws when iterated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.whileDo.html b/docs/functions/Ix.AsyncIterable.whileDo.html index 5149df26..6b68c988 100644 --- a/docs/functions/Ix.AsyncIterable.whileDo.html +++ b/docs/functions/Ix.AsyncIterable.whileDo.html @@ -1,6 +1,123 @@ -whileDo | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function whileDo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • whileDo<TSource>(source, condition): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Repeats the given source as long as the specified conditions holds, where +whileDo | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function whileDo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Repeats the given source as long as the specified conditions holds, where the condition is evaluated before each repeated source is iterated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source to repeat as long as the condition function evaluates to true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • condition: ((signal?) => boolean | Promise<boolean>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Condition that will be evaluated before the source sequence is iterated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (signal?): boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable which is repeated while the condition returns true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source to repeat as long as the condition function evaluates to true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      condition: ((signal?) => boolean | Promise<boolean>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Condition that will be evaluated before the source sequence is iterated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (signal?): boolean | Promise<boolean>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable which is repeated while the condition returns true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.AsyncIterable.zip.html b/docs/functions/Ix.AsyncIterable.zip.html index 69671915..7c75c5f3 100644 --- a/docs/functions/Ix.AsyncIterable.zip.html +++ b/docs/functions/Ix.AsyncIterable.zip.html @@ -1,55 +1,383 @@ -zip | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function zip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2>(source, source2): AsyncIterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3>(source, source2, source3): AsyncIterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3, T4>(source, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3, T4, T5>(source, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3, T4, T5, T6>(source, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T>(...sources): AsyncIterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...sources: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +zip | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function zip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.Iterable.catchAll.html b/docs/functions/Ix.Iterable.catchAll.html index c4872f97..4e0ff03e 100644 --- a/docs/functions/Ix.Iterable.catchAll.html +++ b/docs/functions/Ix.Iterable.catchAll.html @@ -1,4 +1,93 @@ -catchAll | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function catchAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • catchAll<TSource>(source): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates a sequence by concatenating source sequences until a source sequence completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<Iterable<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sequence that continues to concatenate source sequences while errors occur.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +catchAll | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function catchAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates a sequence by concatenating source sequences until a source sequence completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<Iterable<TSource>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sequence that continues to concatenate source sequences while errors occur.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.Iterable.catchError.html b/docs/functions/Ix.Iterable.catchError.html index 4f159bfb..dc1c41f7 100644 --- a/docs/functions/Ix.Iterable.catchError.html +++ b/docs/functions/Ix.Iterable.catchError.html @@ -1,4 +1,93 @@ -catchError | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function catchError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • catchError<TSource>(...source): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates a sequence by concatenating source sequences until a source sequence completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...source: Iterable<TSource>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sequence that continues to concatenate source sequences while errors occur.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sequence that continues to concatenate source sequences while errors occur.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +catchError | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function catchError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates a sequence by concatenating source sequences until a source sequence completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...source: Iterable<TSource>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sequence that continues to concatenate source sequences while errors occur.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sequence that continues to concatenate source sequences while errors occur.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.Iterable.concat.html b/docs/functions/Ix.Iterable.concat.html index 25d9f32b..e4f9b2c2 100644 --- a/docs/functions/Ix.Iterable.concat.html +++ b/docs/functions/Ix.Iterable.concat.html @@ -1,56 +1,366 @@ -concat | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function concat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concat<T>(v1): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v1: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concat<T, T2>(v1, v2): Iterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates the second iterable sequence to the first iterable sequence upon successful termination of the first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v1: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements of the first sequence, +concat | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function concat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v1: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates the second iterable sequence to the first iterable sequence upon successful termination of the first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v1: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements of the first sequence, followed by those of the second the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • concat<T, T2, T3>(v1, v2, v3): Iterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Concatenates all iterable sequences in the given sequences, as long as the previous iterable + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates all iterable sequences in the given sequences, as long as the previous iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v1: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • concat<T, T2, T3, T4>(v1, v2, v3, v4): Iterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Concatenates all iterable sequences in the given sequences, as long as the previous iterable +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v1: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates all iterable sequences in the given sequences, as long as the previous iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v1: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • concat<T, T2, T3, T4, T5>(v1, v2, v3, v4, v5): Iterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Concatenates all iterable sequences in the given sequences, as long as the previous iterable +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v1: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates all iterable sequences in the given sequences, as long as the previous iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v1: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v5: Iterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • concat<T, T2, T3, T4, T5, T6>(v1, v2, v3, v4, v5, v6): Iterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Concatenates all iterable sequences in the given sequences, as long as the previous iterable +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v1: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v5: Iterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates all iterable sequences in the given sequences, as long as the previous iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v1: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v5: Iterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v6: Iterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sixth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v1: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v5: Iterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v6: Iterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sixth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns Iterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.Iterable.create.html b/docs/functions/Ix.Iterable.create.html index 863dec19..64e3c677 100644 --- a/docs/functions/Ix.Iterable.create.html +++ b/docs/functions/Ix.Iterable.create.html @@ -1,4 +1,99 @@ -create | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • create<T>(getIterator): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates a new iterable using the specified function implementing the members of AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements returned by the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • getIterator: (() => Iterator<T, any, undefined>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (): Iterator<T, any, undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns Iterator<T, any, undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A new iterable instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +create | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates a new iterable using the specified function implementing the members of AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements returned by the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getIterator: (() => Iterator<T, any, undefined>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (): Iterator<T, any, undefined>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns Iterator<T, any, undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A new iterable instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.Iterable.defer.html b/docs/functions/Ix.Iterable.defer.html index 5042a1cd..0207c418 100644 --- a/docs/functions/Ix.Iterable.defer.html +++ b/docs/functions/Ix.Iterable.defer.html @@ -1,5 +1,102 @@ -defer | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function defer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • defer<TSource>(factory): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns an iterable sequence that invokes the specified factory function whenever a call to [Symbol.iterator] has been made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sequence returned by the factory function, and in the resulting sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • factory: (() => Iterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      iterable factory function to invoke for each call to [Symbol.iterator].

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence whose observers trigger an invocation of the given iterable factory function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +defer | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function defer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns an iterable sequence that invokes the specified factory function whenever a call to [Symbol.iterator] has been made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sequence returned by the factory function, and in the resulting sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      factory: (() => Iterable<TSource>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      iterable factory function to invoke for each call to [Symbol.iterator].

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (): Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence whose observers trigger an invocation of the given iterable factory function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.Iterable.empty.html b/docs/functions/Ix.Iterable.empty.html index 31a0392f..def9ac5f 100644 --- a/docs/functions/Ix.Iterable.empty.html +++ b/docs/functions/Ix.Iterable.empty.html @@ -1,3 +1,80 @@ -empty | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +empty | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.Iterable.generate.html b/docs/functions/Ix.Iterable.generate.html index 68519d5e..589d3b6c 100644 --- a/docs/functions/Ix.Iterable.generate.html +++ b/docs/functions/Ix.Iterable.generate.html @@ -1,10 +1,150 @@ -generate | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function generate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • generate<TState, TResult>(initialState, condition, iterate, resultSelector): Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Generates an iterable sequence by running a state-driven loop producing the sequence's elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the state used in the generator loop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the produced sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • initialState: TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The initial state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • condition: ((value) => boolean)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Condition to terminate generation (upon returning false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • iterate: ((value) => TState)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Iteration step function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value): TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • resultSelector: ((value) => TResult)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Selector function for results produced in +generate | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function generate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Generates an iterable sequence by running a state-driven loop producing the sequence's elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the state used in the generator loop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the produced sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          initialState: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The initial state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          condition: ((value) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Condition to terminate generation (upon returning false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          iterate: ((value) => TState)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Iteration step function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resultSelector: ((value) => TResult)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Selector function for results produced in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The generated iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value): TResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The generated iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.Iterable.iif.html b/docs/functions/Ix.Iterable.iif.html index 9abe678e..bcc38735 100644 --- a/docs/functions/Ix.Iterable.iif.html +++ b/docs/functions/Ix.Iterable.iif.html @@ -1,7 +1,110 @@ -iif | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function iif

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • iif<TSource>(fn, thenSource, elseSource?): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • If the specified condition evaluates true, select the thenSource sequence. +iif | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function iif

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If the specified condition evaluates true, select the thenSource sequence. Otherwise, select the elseSource sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • fn: (() => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • thenSource: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sequence returned in case evaluates true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional elseSource: Iterable<TSource> = ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sequence returned in case condition evaluates false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      thenSource if condition evaluates true; elseSource otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fn: (() => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (): boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      thenSource: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sequence returned in case evaluates true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional elseSource: Iterable<TSource> = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sequence returned in case condition evaluates false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    thenSource if condition evaluates true; elseSource otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.Iterable.of.html b/docs/functions/Ix.Iterable.of.html index cf282f4e..eb11842e 100644 --- a/docs/functions/Ix.Iterable.of.html +++ b/docs/functions/Ix.Iterable.of.html @@ -1,5 +1,96 @@ -of | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function of

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • of<TSource>(...args): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates an iterable from the specified elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements to create an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...args: TSource[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The elements to turn into an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The iterable sequence created from the elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +of | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function of

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates an iterable from the specified elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements to create an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...args: TSource[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The elements to turn into an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The iterable sequence created from the elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.Iterable.onErrorResumeNext.html b/docs/functions/Ix.Iterable.onErrorResumeNext.html index fc5d0cf2..f38cd60c 100644 --- a/docs/functions/Ix.Iterable.onErrorResumeNext.html +++ b/docs/functions/Ix.Iterable.onErrorResumeNext.html @@ -1,4 +1,93 @@ -onErrorResumeNext | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function onErrorResumeNext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • onErrorResumeNext<T>(...source): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates all of the specified iterable sequences, even if the previous iterable sequence terminated exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...source: Iterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that concatenates the source sequences, even if a sequence terminates exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +onErrorResumeNext | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function onErrorResumeNext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Concatenates all of the specified iterable sequences, even if the previous iterable sequence terminated exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...source: Iterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that concatenates the source sequences, even if a sequence terminates exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.Iterable.range.html b/docs/functions/Ix.Iterable.range.html index 3026e145..5f045b40 100644 --- a/docs/functions/Ix.Iterable.range.html +++ b/docs/functions/Ix.Iterable.range.html @@ -1,5 +1,93 @@ -range | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • range(start, count): Iterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Generates an iterable sequence of integral numbers within a specified range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • start: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value of the first integer in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • count: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of sequential integers to generate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains a range of sequential integral numbers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +range | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Generates an iterable sequence of integral numbers within a specified range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      start: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value of the first integer in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of sequential integers to generate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains a range of sequential integral numbers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.Iterable.repeatValue.html b/docs/functions/Ix.Iterable.repeatValue.html index 73b846ed..8554a5bf 100644 --- a/docs/functions/Ix.Iterable.repeatValue.html +++ b/docs/functions/Ix.Iterable.repeatValue.html @@ -1,6 +1,101 @@ -repeatValue | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function repeatValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repeatValue<TSource>(value, count?): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Repeats a given value for the specified number of times as an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of element to repeat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • value: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to repeat as an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional count: number = -1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of times to repeat the value, infinite if not specified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable with a single item that is repeated over the specified times.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +repeatValue | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function repeatValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Repeats a given value for the specified number of times as an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of element to repeat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to repeat as an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional count: number = -1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of times to repeat the value, infinite if not specified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable with a single item that is repeated over the specified times.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.Iterable.throwError.html b/docs/functions/Ix.Iterable.throwError.html index 569c05df..98f0278f 100644 --- a/docs/functions/Ix.Iterable.throwError.html +++ b/docs/functions/Ix.Iterable.throwError.html @@ -1,4 +1,93 @@ -throwError | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function throwError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • throwError<TSource>(error): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates an async-iterable that throws the specified error upon iterating.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource = any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • error: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The error to throw upon iterating the iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable that throws when iterated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +throwError | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function throwError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates an async-iterable that throws the specified error upon iterating.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource = any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      error: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The error to throw upon iterating the iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable that throws when iterated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.Iterable.whileDo.html b/docs/functions/Ix.Iterable.whileDo.html index 93a26b05..f754d68f 100644 --- a/docs/functions/Ix.Iterable.whileDo.html +++ b/docs/functions/Ix.Iterable.whileDo.html @@ -1,6 +1,106 @@ -whileDo | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function whileDo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • whileDo<TSource>(source, condition): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Repeats the given source as long as the specified conditions holds, where +whileDo | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function whileDo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Repeats the given source as long as the specified conditions holds, where the condition is evaluated before each repeated source is iterated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source to repeat as long as the condition function evaluates to true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • condition: (() => boolean)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Condition that will be evaluated before the source sequence is iterated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable which is repeated while the condition returns true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source to repeat as long as the condition function evaluates to true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      condition: (() => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Condition that will be evaluated before the source sequence is iterated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (): boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable which is repeated while the condition returns true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix.Iterable.zip.html b/docs/functions/Ix.Iterable.zip.html index 15b15ec1..b0d2b40a 100644 --- a/docs/functions/Ix.Iterable.zip.html +++ b/docs/functions/Ix.Iterable.zip.html @@ -1,55 +1,371 @@ -zip | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function zip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2>(source, source2): Iterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3>(source, source2, source3): Iterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3, T4>(source, source2, source3, source4): Iterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3, T4, T5>(source, source2, source3, source4, source5): Iterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: Iterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3, T4, T5, T6>(source, source2, source3, source4, source5, source6): Iterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: Iterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source6: Iterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T>(...sources): Iterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...sources: Iterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +zip | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function zip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: Iterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: Iterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source6: Iterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: Iterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix_dom.fromDOMStream.html b/docs/functions/Ix_dom.fromDOMStream.html deleted file mode 100644 index fdaa121d..00000000 --- a/docs/functions/Ix_dom.fromDOMStream.html +++ /dev/null @@ -1,10 +0,0 @@ -fromDOMStream | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fromDOMStream<TSource>(stream): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates an async-iterable from an existing DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • stream: ReadableStream<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The DOM Readable stream to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable containing the elements from the ReadableStream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fromDOMStream<TSource>(stream, options): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates an async-iterable from an existing DOM stream and options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource extends ArrayBufferView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • stream: ReadableStream<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The readable stream to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mode: "byob";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options to set the mode for the DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mode: "byob"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable created from the incoming async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/Ix_node.fromNodeStream.html b/docs/functions/Ix_node.fromNodeStream.html deleted file mode 100644 index 5a30f258..00000000 --- a/docs/functions/Ix_node.fromNodeStream.html +++ /dev/null @@ -1,5 +0,0 @@ -fromNodeStream | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromNodeStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fromNodeStream(stream, size?): AsyncIterable<string | Buffer>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates a new async-iterable from a Node.js stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • stream: ReadableStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Node.js stream to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional size: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The size of the buffers for the stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<string | Buffer>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable containing data from the stream either in string or Buffer format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable._concatAll.html b/docs/functions/asynciterable._concatAll.html index 1363862f..6825245e 100644 --- a/docs/functions/asynciterable._concatAll.html +++ b/docs/functions/asynciterable._concatAll.html @@ -1 +1,119 @@ -_concatAll | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function _concatAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +_concatAll | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function _concatAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.as.html b/docs/functions/asynciterable.as.html index b570eb8f..e99f42fc 100644 --- a/docs/functions/asynciterable.as.html +++ b/docs/functions/asynciterable.as.html @@ -1,12 +1,171 @@ -as | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function as

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • as(source): AsyncIterable<string>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts an existing string into an async-iterable of characters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The string to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<string>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable stream of characters from the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • as<T>(source): AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts the AsyncIterable-like input or single element into an AsyncIterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the async-iterable like sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: T | AsyncIterableInput<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable like input to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable stream from elements in the async-iterable like sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • as<T>(source): AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts the single element into an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the input to turn into an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The single element to turn into an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence which contains the single element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +as | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function as

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an existing string into an async-iterable of characters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The string to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<string>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable stream of characters from the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts the AsyncIterable-like input or single element into an AsyncIterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the async-iterable like sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: T | AsyncIterableInput<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable like input to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable stream from elements in the async-iterable like sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts the single element into an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the input to turn into an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The single element to turn into an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence which contains the single element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.asyncify.html b/docs/functions/asynciterable.asyncify.html index e7ad6f26..6fe7005b 100644 --- a/docs/functions/asynciterable.asyncify.html +++ b/docs/functions/asynciterable.asyncify.html @@ -1,5 +1,151 @@ -asyncify | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function asyncify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • asyncify<TSource>(func): ((...args) => AsyncIterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts the callback function into wrapped function which returns an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the value returned from the callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • func: ((...xs) => any)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The callback function to wrap as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...xs): any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Rest ...xs: any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ((...args) => AsyncIterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A function when invoked, returns an async-iterable from the callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +asyncify | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function asyncify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts the callback function into wrapped function which returns an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the value returned from the callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func: ((...xs) => any)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The callback function to wrap as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...xs): any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Rest ...xs: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ((...args) => AsyncIterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A function when invoked, returns an async-iterable from the callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.asyncifyErrback.html b/docs/functions/asynciterable.asyncifyErrback.html index 4022fb4c..da541ffd 100644 --- a/docs/functions/asynciterable.asyncifyErrback.html +++ b/docs/functions/asynciterable.asyncifyErrback.html @@ -1,5 +1,151 @@ -asyncifyErrback | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function asyncifyErrback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • asyncifyErrback<TSource>(func): ((...args) => AsyncIterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts a Node.js style error first callback to an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the returned value from the callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • func: ((...xs) => any)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Node.js error first callback to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...xs): any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Rest ...xs: any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ((...args) => AsyncIterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A function, when invoked, contains the result of the callback as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +asyncifyErrback | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function asyncifyErrback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts a Node.js style error first callback to an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the returned value from the callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func: ((...xs) => any)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Node.js error first callback to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...xs): any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Rest ...xs: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ((...args) => AsyncIterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A function, when invoked, contains the result of the callback as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.average.html b/docs/functions/asynciterable.average.html index 8d7d7072..e96e9d37 100644 --- a/docs/functions/asynciterable.average.html +++ b/docs/functions/asynciterable.average.html @@ -1,10 +1,156 @@ -average | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function average

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • average(source, options?): Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Computes the average of the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source async-iterable sequence to compute the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: MathOptions<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for calculating the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Promise which returns the computed average for the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • average<TSource>(source, options?): Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Computes the average of the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source async-iterable sequence to compute the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: MathOptions<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for calculating the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Promise which returns the computed average for the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +average | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function average

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Computes the average of the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source async-iterable sequence to compute the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: MathOptions<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for calculating the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Promise which returns the computed average for the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Computes the average of the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source async-iterable sequence to compute the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: MathOptions<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for calculating the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Promise which returns the computed average for the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.combineLatest.html b/docs/functions/asynciterable.combineLatest.html index 36134d1f..73554ba5 100644 --- a/docs/functions/asynciterable.combineLatest.html +++ b/docs/functions/asynciterable.combineLatest.html @@ -1,61 +1,410 @@ -combineLatest | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function combineLatest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • combineLatest<T, T2>(source, source2): AsyncIterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +combineLatest | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function combineLatest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • combineLatest<T, T2, T3>(source, source2, source3): AsyncIterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • combineLatest<T, T2, T3, T4>(source, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • combineLatest<T, T2, T3, T4, T5>(source, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • combineLatest<T, T2, T3, T4, T5, T6>(source, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • combineLatest<T>(...sources): AsyncIterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Rest ...sources: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The async-iterable sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.concat.html b/docs/functions/asynciterable.concat.html index f73dfe42..05c4e6d2 100644 --- a/docs/functions/asynciterable.concat.html +++ b/docs/functions/asynciterable.concat.html @@ -1,58 +1,386 @@ -concat | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function concat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concat<T, T2>(v1, v2): AsyncIterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates the second async-iterable sequence to the first async-iterable sequence upon successful termination of the first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v1: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains the elements of the first sequence, +concat | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function concat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates the second async-iterable sequence to the first async-iterable sequence upon successful termination of the first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v1: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements of the first sequence, followed by those of the second the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • concat<T, T2, T3>(v1, v2, v3): AsyncIterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v1: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • concat<T, T2, T3, T4>(v1, v2, v3, v4): AsyncIterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v1: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v1: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • concat<T, T2, T3, T4, T5>(v1, v2, v3, v4, v5): AsyncIterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v1: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v1: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements of each +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v1: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concat<T, T2, T3, T4, T5, T6>(v1, v2, v3, v4, v5, v6): AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v1: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains the elements of each +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v1: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.count.html b/docs/functions/asynciterable.count.html index a7420762..9c456f4e 100644 --- a/docs/functions/asynciterable.count.html +++ b/docs/functions/asynciterable.count.html @@ -1,8 +1,136 @@ -count | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function count

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • count<T>(source, options?): Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns a promise that represents how many elements in the specified async-iterable sequence satisfy a condition +count | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function count

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns a promise that represents how many elements in the specified async-iterable sequence satisfy a condition otherwise, the number of items in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source collection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An async-iterable sequence that contains elements to be counted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional options: OptionalFindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The options for a predicate for filtering, thisArg for binding and AbortSignal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of matching elements for the given condition if provided, otherwise +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source collection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains elements to be counted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: OptionalFindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for a predicate for filtering, thisArg for binding and AbortSignal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The number of matching elements for the given condition if provided, otherwise the number of elements in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.create.html b/docs/functions/asynciterable.create.html index ba837bb2..59057a4f 100644 --- a/docs/functions/asynciterable.create.html +++ b/docs/functions/asynciterable.create.html @@ -1,5 +1,140 @@ -create | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • create<T>(fn): AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates a new iterable using the specified function implementing the members of AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements returned by the enumerable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • fn: ((signal?) => AsyncIterator<T, any, undefined> | Promise<AsyncIterator<T, any, undefined>>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The function that creates the Symbol.asyncIterator method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (signal?): AsyncIterator<T, any, undefined> | Promise<AsyncIterator<T, any, undefined>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns AsyncIterator<T, any, undefined> | Promise<AsyncIterator<T, any, undefined>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A new async-iterable instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +create | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates a new iterable using the specified function implementing the members of AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements returned by the enumerable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fn: ((signal?) => AsyncIterator<T, any, undefined> | Promise<AsyncIterator<T, any, undefined>>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The function that creates the Symbol.asyncIterator method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (signal?): AsyncIterator<T, any, undefined> | Promise<AsyncIterator<T, any, undefined>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns AsyncIterator<T, any, undefined> | Promise<AsyncIterator<T, any, undefined>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A new async-iterable instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.defer.html b/docs/functions/asynciterable.defer.html index 9266a706..1ef20b68 100644 --- a/docs/functions/asynciterable.defer.html +++ b/docs/functions/asynciterable.defer.html @@ -1,6 +1,141 @@ -defer | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function defer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • defer<TSource>(factory): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns an async-iterable sequence that invokes the specified factory function whenever a call to [Symbol.asyncIterator] has been made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sequence returned by the factory function, and in the resulting sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • factory: ((signal?) => AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async-iterable factory function to +defer | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function defer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns an async-iterable sequence that invokes the specified factory function whenever a call to [Symbol.asyncIterator] has been made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the sequence returned by the factory function, and in the resulting sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          factory: ((signal?) => AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Async-iterable factory function to invoke for each call to [Symbol.asyncIterator].

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (signal?): AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An async-iterable sequence whose observers trigger an invocation of the given async-iterable factory function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (signal?): AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence whose observers trigger an invocation of the given async-iterable factory function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.elementAt.html b/docs/functions/asynciterable.elementAt.html index 5dd3c74a..8e7c3103 100644 --- a/docs/functions/asynciterable.elementAt.html +++ b/docs/functions/asynciterable.elementAt.html @@ -1,8 +1,140 @@ -elementAt | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function elementAt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • elementAt<T>(source, index, signal?): Promise<T | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the element at a specified index in a sequence or undefined if the index is out of range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      async-iterable sequence to return the element from.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The zero-based index of the element to retrieve.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The optional abort signal to be used for cancelling the sequence at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<T | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that produces the element at the specified +elementAt | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function elementAt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns the element at a specified index in a sequence or undefined if the index is out of range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        async-iterable sequence to return the element from.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The zero-based index of the element to retrieve.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The optional abort signal to be used for cancelling the sequence at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Promise<T | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that produces the element at the specified position in the source sequence, or undefined if the index is outside the bounds of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.empty.html b/docs/functions/asynciterable.empty.html index ab6aa1e5..f5da9b5a 100644 --- a/docs/functions/asynciterable.empty.html +++ b/docs/functions/asynciterable.empty.html @@ -1,3 +1,113 @@ -empty | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +empty | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.every.html b/docs/functions/asynciterable.every.html index ff247ba0..9f43f8a7 100644 --- a/docs/functions/asynciterable.every.html +++ b/docs/functions/asynciterable.every.html @@ -1,7 +1,135 @@ -every | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function every

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • every<T>(source, options): Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Determines whether all elements of an async-iterable sequence satisfy a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: FindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for a predicate for filtering, thisArg for binding and AbortSignal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence containing a single element determining whether all elements in the +every | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function every

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines whether all elements of an async-iterable sequence satisfy a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An async-iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options: FindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The options for a predicate for filtering, thisArg for binding and AbortSignal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing a single element determining whether all elements in the source sequence pass the test in the specified predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.find.html b/docs/functions/asynciterable.find.html index bba608c4..e9237df8 100644 --- a/docs/functions/asynciterable.find.html +++ b/docs/functions/asynciterable.find.html @@ -1,6 +1,134 @@ -find | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function find

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • find<T>(source, options): Promise<T | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the value of the first element in the provided async-iterable that satisfies the provided testing function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: FindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for a predicate for filtering, thisArg for binding and AbortSignal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<T | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise with the value of the first element that matches the predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +find | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function find

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the value of the first element in the provided async-iterable that satisfies the provided testing function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: FindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for a predicate for filtering, thisArg for binding and AbortSignal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<T | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise with the value of the first element that matches the predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.findIndex.html b/docs/functions/asynciterable.findIndex.html index e86267a5..06e2c345 100644 --- a/docs/functions/asynciterable.findIndex.html +++ b/docs/functions/asynciterable.findIndex.html @@ -1,7 +1,135 @@ -findIndex | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function findIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • findIndex<T>(source, options): Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the a Promise containing the index of the first element in the array that satisfies the provided testing function. +findIndex | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function findIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns the a Promise containing the index of the first element in the array that satisfies the provided testing function. Otherwise, it returns a Promise with -1, indicating that no element passed the test.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An async-iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • options: FindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The options for a predicate for filtering, thisArg for binding and AbortSignal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A promise containing the index of the first element in the array that passes the test. Otherwise, -1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: FindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for a predicate for filtering, thisArg for binding and AbortSignal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing the index of the first element in the array that passes the test. Otherwise, -1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.first.html b/docs/functions/asynciterable.first.html index acf2c9ec..e311b3a5 100644 --- a/docs/functions/asynciterable.first.html +++ b/docs/functions/asynciterable.first.html @@ -1,6 +1,132 @@ -first | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function first

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • first<T>(source, options?): Promise<T | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the first element of an async-iterable sequence that matches the predicate if provided, or undefined if no such element exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source async-enumerable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: OptionalFindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<T | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Promise containing the first element in the async-iterable sequence, +first | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function first

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns the first element of an async-iterable sequence that matches the predicate if provided, or undefined if no such element exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source async-enumerable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional options: OptionalFindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Promise<T | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A Promise containing the first element in the async-iterable sequence, or a default value if no such element exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.forkJoin.html b/docs/functions/asynciterable.forkJoin.html index a7a44bd0..8912e2b8 100644 --- a/docs/functions/asynciterable.forkJoin.html +++ b/docs/functions/asynciterable.forkJoin.html @@ -1,120 +1,764 @@ -forkJoin | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function forkJoin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2>(source, source2): Promise<[T, T2] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3>(source, source2, source3): Promise<[T, T2, T3] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3, T4>(source, source2, source3, source4): Promise<[T, T2, T3, T4] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3, T4, T5>(source, source2, source3, source4, source5): Promise<[T, T2, T3, T4, T5] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3, T4, T5, T6>(source, source2, source3, source4, source5, source6): Promise<[T, T2, T3, T4, T5, T6] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5, T6] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T>(signal, source): Promise<[T] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2>(signal, source, source2): Promise<[T, T2] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3>(signal, source, source2, source3): Promise<[T, T2, T3] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3, T4>(signal, source, source2, source3, source4): Promise<[T, T2, T3, T4] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3, T4, T5>(signal, source, source2, source3, source4, source5): Promise<[T, T2, T3, T4, T5] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T, T2, T3, T4, T5, T6>(signal, source, source2, source3, source4, source5, source6): Promise<[T, T2, T3, T4, T5, T6] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5, T6] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T>(...sources): Promise<T[] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...sources: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<T[] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • forkJoin<T>(signal, ...sources): Promise<T[] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...sources: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<T[] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +forkJoin | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function forkJoin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5, T6] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<[T, T2, T3, T4, T5, T6] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<T[] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs all specified async-iterable sequences in parallel and collects their last elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An abort signal used for cancellation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<T[] | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with an array of all the last elements of all sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.from.html b/docs/functions/asynciterable.from.html index 6ee76fa5..84831267 100644 --- a/docs/functions/asynciterable.from.html +++ b/docs/functions/asynciterable.from.html @@ -1 +1,140 @@ -from | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • from<TSource, TResult>(source, selector?, thisArg?): AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterableInput<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • selector: ((value, index) => TResult | Promise<TResult>) = identityAsync
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index): TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional thisArg: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nocollapse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +from | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TResult = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterableInput<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selector: ((value, index) => TResult | Promise<TResult>) = identityAsync
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index): TResult | Promise<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional thisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nocollapse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.fromEvent.html b/docs/functions/asynciterable.fromEvent.html index 53daf760..2b1059d0 100644 --- a/docs/functions/asynciterable.fromEvent.html +++ b/docs/functions/asynciterable.fromEvent.html @@ -1,21 +1,254 @@ -fromEvent | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fromEvent<TSource>(obj, eventName): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts an event emitter event into an async-iterable stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the emitter stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: EventedTarget

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The object that emits the events to turn into an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • eventName: string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence created from the events emitted from the evented target.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fromEvent<TSource>(obj, eventName, resultSelector): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts an event emitter event into an async-iterable stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the emitter stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: EventedTarget

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The object that emits the events to turn into an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • eventName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • resultSelector: ((...args) => TSource)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The result selector for the event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...args): TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Rest ...args: any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence created from the events emitted from the evented target.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fromEvent<TSource>(obj, eventName, options): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts an event emitter event into an async-iterable stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the emitter stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: EventedTarget

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The object that emits the events to turn into an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • eventName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: EventListenerOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for listening to the events such as capture, passive and once.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence created from the events emitted from the evented target.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fromEvent<TSource>(obj, eventName, options, resultSelector): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts an event emitter event into an async-iterable stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the emitter stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: EventedTarget

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The object that emits the events to turn into an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • eventName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: EventListenerOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for listening to the events such as capture, passive and once.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • resultSelector: ((...args) => TSource)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The result selector for the event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...args): TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Rest ...args: any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence created from the events emitted from the evented target.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +fromEvent | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an event emitter event into an async-iterable stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the emitter stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      obj: EventedTarget
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The object that emits the events to turn into an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      eventName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence created from the events emitted from the evented target.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an event emitter event into an async-iterable stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the emitter stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      obj: EventedTarget
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The object that emits the events to turn into an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      eventName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resultSelector: ((...args) => TSource)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The result selector for the event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...args): TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Rest ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence created from the events emitted from the evented target.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an event emitter event into an async-iterable stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the emitter stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      obj: EventedTarget
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The object that emits the events to turn into an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      eventName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: EventListenerOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for listening to the events such as capture, passive and once.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence created from the events emitted from the evented target.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an event emitter event into an async-iterable stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the emitter stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      obj: EventedTarget
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The object that emits the events to turn into an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      eventName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: EventListenerOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for listening to the events such as capture, passive and once.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resultSelector: ((...args) => TSource)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The result selector for the event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...args): TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Rest ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence created from the events emitted from the evented target.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.fromEventPattern.html b/docs/functions/asynciterable.fromEventPattern.html index 354c3e6e..639ece79 100644 --- a/docs/functions/asynciterable.fromEventPattern.html +++ b/docs/functions/asynciterable.fromEventPattern.html @@ -1,6 +1,191 @@ -fromEventPattern | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromEventPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fromEventPattern<TSource>(addHandler, removeHandler, resultSelector?): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates async-iterable from an event emitter by adding handlers for both listening and unsubscribing from events.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the event emitter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • addHandler: ((handler) => void)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The function to add a listener to the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (handler): void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • handler: ((...args) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • (...args): void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Rest ...args: any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • removeHandler: ((handler) => void)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The function to remove a listener from the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (handler): void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • handler: ((...args) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • (...args): void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Rest ...args: any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional resultSelector: ((...args) => TSource)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...args): TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Rest ...args: any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable which contains the data from the underlying events as wrapped by the handlers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +fromEventPattern | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromEventPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates async-iterable from an event emitter by adding handlers for both listening and unsubscribing from events.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the event emitter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      addHandler: ((handler) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The function to add a listener to the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (handler): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handler: ((...args) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • (...args): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Rest ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      removeHandler: ((handler) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The function to remove a listener from the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (handler): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handler: ((...args) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • (...args): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Rest ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional resultSelector: ((...args) => TSource)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (...args): TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Rest ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable which contains the data from the underlying events as wrapped by the handlers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.generate.html b/docs/functions/asynciterable.generate.html index 47c202d9..420637c0 100644 --- a/docs/functions/asynciterable.generate.html +++ b/docs/functions/asynciterable.generate.html @@ -1,10 +1,189 @@ -generate | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function generate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • generate<TState, TResult>(initialState, condition, iterate, resultSelector): AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Generates an async-iterable sequence by running a state-driven loop producing the sequence's elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the state used in the generator loop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the produced sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • initialState: TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The initial state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • condition: ((value, signal?) => boolean | Promise<boolean>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Condition to terminate generation (upon returning false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • iterate: ((value, signal?) => TState | Promise<TState>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Iteration step function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): TState | Promise<TState>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TState | Promise<TState>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • resultSelector: ((value, signal?) => TResult | Promise<TResult>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Selector function for results produced in +generate | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function generate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Generates an async-iterable sequence by running a state-driven loop producing the sequence's elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the state used in the generator loop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the produced sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          initialState: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The initial state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          condition: ((value, signal?) => boolean | Promise<boolean>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Condition to terminate generation (upon returning false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): boolean | Promise<boolean>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          iterate: ((value, signal?) => TState | Promise<TState>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Iteration step function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TState | Promise<TState>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TState | Promise<TState>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resultSelector: ((value, signal?) => TResult | Promise<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Selector function for results produced in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The generated async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): TResult | Promise<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The generated async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.generateTime.html b/docs/functions/asynciterable.generateTime.html index 15036094..1d5ae992 100644 --- a/docs/functions/asynciterable.generateTime.html +++ b/docs/functions/asynciterable.generateTime.html @@ -1,11 +1,207 @@ -generateTime | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function generateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • generateTime<TState, TResult>(initialState, condition, iterate, resultSelector, timeSelector): AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Generates an async-iterable sequence by running a time-based state-driven loop producing the sequence's elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the state used in the generator loop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the produced sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • initialState: TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The initial state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • condition: ((value, signal?) => boolean | Promise<boolean>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Condition to terminate generation (upon returning false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • iterate: ((value, signal?) => TState | Promise<TState>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Iteration step function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): TState | Promise<TState>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TState | Promise<TState>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • resultSelector: ((value, signal?) => TResult | Promise<TResult>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Selector function for results produced in +generateTime | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function generateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Generates an async-iterable sequence by running a time-based state-driven loop producing the sequence's elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the state used in the generator loop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the produced sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          initialState: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The initial state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          condition: ((value, signal?) => boolean | Promise<boolean>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Condition to terminate generation (upon returning false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): boolean | Promise<boolean>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          iterate: ((value, signal?) => TState | Promise<TState>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Iteration step function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TState | Promise<TState>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TState | Promise<TState>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resultSelector: ((value, signal?) => TResult | Promise<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Selector function for results produced in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • timeSelector: ((value, signal?) => number | Promise<number>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Selector function for how much time to wait.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): number | Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns number | Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The generated async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): TResult | Promise<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      timeSelector: ((value, signal?) => number | Promise<number>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Selector function for how much time to wait.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): number | Promise<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns number | Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The generated async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.includes.html b/docs/functions/asynciterable.includes.html index f458cc33..054952b5 100644 --- a/docs/functions/asynciterable.includes.html +++ b/docs/functions/asynciterable.includes.html @@ -1,8 +1,144 @@ -includes | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function includes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • includes<T>(source, valueToFind, fromIndex?, signal?): Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Determines whether an async-itreable includes a certain value among its entries, returning true or false as appropriate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence to search for the item.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • valueToFind: T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to search for.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional fromIndex: number = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The position in this async-iterable at which to begin searching for valueToFind.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An optional abort signal to cancel the operation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a promise containing true if the value valueToFind is found within the async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +includes | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function includes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines whether an async-itreable includes a certain value among its entries, returning true or false as appropriate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence to search for the item.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      valueToFind: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to search for.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional fromIndex: number = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The position in this async-iterable at which to begin searching for valueToFind.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An optional abort signal to cancel the operation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a promise containing true if the value valueToFind is found within the async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.interval.html b/docs/functions/asynciterable.interval.html index 11037bbe..ae4fec91 100644 --- a/docs/functions/asynciterable.interval.html +++ b/docs/functions/asynciterable.interval.html @@ -1,4 +1,121 @@ -interval | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function interval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • interval(dueTime): AsyncIterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Produces a new item in an async-iterable at the given interval cycle time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • dueTime: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The due time in milliseconds to spawn a new item.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable producing values at the specified interval.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +interval | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function interval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Produces a new item in an async-iterable at the given interval cycle time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dueTime: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The due time in milliseconds to spawn a new item.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable producing values at the specified interval.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.isEmpty.html b/docs/functions/asynciterable.isEmpty.html index e6706d56..2e336827 100644 --- a/docs/functions/asynciterable.isEmpty.html +++ b/docs/functions/asynciterable.isEmpty.html @@ -1,6 +1,134 @@ -isEmpty | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • isEmpty<T>(source, signal?): Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Determines whether the given async-iterable is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source async-iterable to determine whether it is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An optional abort signal to cancel the operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a promise containing true if the sequence is empty, otherwise false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +isEmpty | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines whether the given async-iterable is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source async-iterable to determine whether it is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An optional abort signal to cancel the operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a promise containing true if the sequence is empty, otherwise false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.last.html b/docs/functions/asynciterable.last.html index 0fd73c88..ba26cc5a 100644 --- a/docs/functions/asynciterable.last.html +++ b/docs/functions/asynciterable.last.html @@ -1,8 +1,136 @@ -last | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function last

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • last<T>(source, options?): Promise<T | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the last element of an async-iterable sequence that satisfies the condition in the predicate if given +last | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function last

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns the last element of an async-iterable sequence that satisfies the condition in the predicate if given otherwise the last item in the sequence, or a default value if no such element exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The source async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional options: OptionalFindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The options which include an optional predicate for filtering, +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The source async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional options: OptionalFindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The options which include an optional predicate for filtering, thirArg for binding, and abort signal for cancellation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Promise<T | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A promise containing the last value that matches the optional predicate or last item, otherwise undefined.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns Promise<T | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A promise containing the last value that matches the optional predicate or last item, otherwise undefined.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.max.html b/docs/functions/asynciterable.max.html index cfb7fc21..dd7a96bc 100644 --- a/docs/functions/asynciterable.max.html +++ b/docs/functions/asynciterable.max.html @@ -1,6 +1,136 @@ -max | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • max<TSource, TResult>(source, options?): Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the maximum element with the optional selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence to determine the maximum element of.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: ExtremaOptions<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which include an optional comparer and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The maximum element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +max | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the maximum element with the optional selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TResult = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence to determine the maximum element of.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: ExtremaOptions<TSource, TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which include an optional comparer and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The maximum element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.maxBy.html b/docs/functions/asynciterable.maxBy.html index 510977e2..8767877d 100644 --- a/docs/functions/asynciterable.maxBy.html +++ b/docs/functions/asynciterable.maxBy.html @@ -1,7 +1,139 @@ -maxBy | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function maxBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • maxBy<TSource, TKey>(source, options?): Promise<TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the elements in an async-iterable sequence with the maximum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence to get the maximum elements for.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: ExtremaOptions<TSource, TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which include an optional comparer and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing a list of zero or more elements that have a maximum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +maxBy | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function maxBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the elements in an async-iterable sequence with the maximum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence to get the maximum elements for.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: ExtremaOptions<TSource, TKey>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which include an optional comparer and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing a list of zero or more elements that have a maximum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.merge.html b/docs/functions/asynciterable.merge.html index 924341cc..b2768ff4 100644 --- a/docs/functions/asynciterable.merge.html +++ b/docs/functions/asynciterable.merge.html @@ -1,60 +1,413 @@ -merge | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function merge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • merge<T, T2>(source, v2): AsyncIterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • merge<T, T2, T3>(source, v2, v3): AsyncIterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The merged elements from all of the specified async-iterable sequences +merge | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function merge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • merge<T, T2, T3, T4>(source, v2, v3, v4): AsyncIterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • merge<T, T2, T3, T4, T5>(source, v2, v3, v4, v5): AsyncIterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • merge<T, T2, T3, T4, T5, T6>(source, v2, v3, v4, v5, v6): AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The sixth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The sixth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • merge<T>(source, ...args): AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the sequence to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Rest ...args: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The async-iterable sources to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sequence to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...args: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable sources to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.min.html b/docs/functions/asynciterable.min.html index 74b3153e..c88c1fdd 100644 --- a/docs/functions/asynciterable.min.html +++ b/docs/functions/asynciterable.min.html @@ -1,8 +1,138 @@ -min | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • min<TSource, TResult>(source, options?): Promise<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +min | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns the minimum element with the optional selector.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • TResult = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • source: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An async-iterable sequence to determine the minimum element of.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optional options: ExtremaOptions<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The options which include an optional comparer and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A promise containing the minimum element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TResult = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence to determine the minimum element of.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: ExtremaOptions<TSource, TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which include an optional comparer and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing the minimum element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.minBy.html b/docs/functions/asynciterable.minBy.html index bfafb398..846b7ad5 100644 --- a/docs/functions/asynciterable.minBy.html +++ b/docs/functions/asynciterable.minBy.html @@ -1,7 +1,139 @@ -minBy | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function minBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • minBy<TSource, TKey>(source, options?): Promise<TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the elements in an async-enumerable sequence with the minimum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence to get the minimum elements for.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: ExtremaOptions<TSource, TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which include an optional comparer and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing a list of zero or more elements that have a minimum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +minBy | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function minBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the elements in an async-enumerable sequence with the minimum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence to get the minimum elements for.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: ExtremaOptions<TSource, TKey>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which include an optional comparer and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing a list of zero or more elements that have a minimum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.never.html b/docs/functions/asynciterable.never.html index 6d7989b6..82d66933 100644 --- a/docs/functions/asynciterable.never.html +++ b/docs/functions/asynciterable.never.html @@ -1,3 +1,113 @@ -never | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function never

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +never | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function never

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.onErrorResumeNext.html b/docs/functions/asynciterable.onErrorResumeNext.html index 02d69870..47f48880 100644 --- a/docs/functions/asynciterable.onErrorResumeNext.html +++ b/docs/functions/asynciterable.onErrorResumeNext.html @@ -1,5 +1,129 @@ -onErrorResumeNext | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function onErrorResumeNext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • onErrorResumeNext<T>(...args): AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates all of the specified async-iterable sequences, even if the previous async-iterable sequence terminated exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...args: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async-iterable sequences to concatenate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that concatenates the source sequences, even if a sequence terminates exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +onErrorResumeNext | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function onErrorResumeNext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Concatenates all of the specified async-iterable sequences, even if the previous async-iterable sequence terminated exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...args: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async-iterable sequences to concatenate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that concatenates the source sequences, even if a sequence terminates exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.race.html b/docs/functions/asynciterable.race.html index 68754ffe..cfd6e325 100644 --- a/docs/functions/asynciterable.race.html +++ b/docs/functions/asynciterable.race.html @@ -1,4 +1,126 @@ -race | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function race

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • race<TSource>(...sources): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Propagates the async sequence that reacts first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...sources: AsyncIterable<TSource>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async sequence that surfaces either of the given sequences, whichever reacted first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +race | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function race

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Propagates the async sequence that reacts first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: AsyncIterable<TSource>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async sequence that surfaces either of the given sequences, whichever reacted first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.range.html b/docs/functions/asynciterable.range.html index 5625366c..b7c98990 100644 --- a/docs/functions/asynciterable.range.html +++ b/docs/functions/asynciterable.range.html @@ -1,5 +1,126 @@ -range | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • range(start, count): AsyncIterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Generates an async-iterable sequence of integral numbers within a specified range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • start: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value of the first integer in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • count: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of sequential integers to generate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains a range of sequential integral numbers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +range | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Generates an async-iterable sequence of integral numbers within a specified range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      start: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value of the first integer in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of sequential integers to generate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains a range of sequential integral numbers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.reduce.html b/docs/functions/asynciterable.reduce.html index cd9ffc03..0ab556c1 100644 --- a/docs/functions/asynciterable.reduce.html +++ b/docs/functions/asynciterable.reduce.html @@ -1,9 +1,141 @@ -reduce | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function reduce

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • reduce<T, R>(source, options): Promise<R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Applies an accumulator function over an async-iterable sequence, returning the result of the aggregation as a +reduce | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function reduce

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Applies an accumulator function over an async-iterable sequence, returning the result of the aggregation as a single element in the result sequence. The seed value, if specified, is used as the initial accumulator value. For aggregation behavior with incremental intermediate results, scan.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An async-iterable sequence to aggregate over.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • options: ReduceOptions<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The options which contains a callback, with optional seedn and an optional abort signal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Promise<R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A promise with the final accumulator value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence to aggregate over.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ReduceOptions<T, R>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which contains a callback, with optional seedn and an optional abort signal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise with the final accumulator value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.reduceRight.html b/docs/functions/asynciterable.reduceRight.html index 1e2b3718..f4d564b4 100644 --- a/docs/functions/asynciterable.reduceRight.html +++ b/docs/functions/asynciterable.reduceRight.html @@ -1,9 +1,141 @@ -reduceRight | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function reduceRight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • reduceRight<T, R>(source, options): Promise<R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Applies an accumulator function over an async-iterable sequence from the end, returning the result of the aggregation as a +reduceRight | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function reduceRight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Applies an accumulator function over an async-iterable sequence from the end, returning the result of the aggregation as a single element in the result sequence. The seed value, if specified, is used as the initial accumulator value. For aggregation behavior with incremental intermediate results, scan.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An async-iterable sequence to aggregate over from the right.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • options: ReduceOptions<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The options which contains a callback, with optional seed and an optional abort signal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Promise<R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A promise with the final accumulator value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence to aggregate over from the right.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ReduceOptions<T, R>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which contains a callback, with optional seed and an optional abort signal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise with the final accumulator value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.repeatValue.html b/docs/functions/asynciterable.repeatValue.html index 0a2a8378..4b258658 100644 --- a/docs/functions/asynciterable.repeatValue.html +++ b/docs/functions/asynciterable.repeatValue.html @@ -1,6 +1,134 @@ -repeatValue | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function repeatValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repeatValue<TSource>(value, count?): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Repeats a given value for the specified number of times as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of element to repeat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • value: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to repeat as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional count: number = -1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of times to repeat the value, infinite if not specified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable with a single item that is repeated over the specified times.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +repeatValue | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function repeatValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Repeats a given value for the specified number of times as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of element to repeat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to repeat as an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional count: number = -1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of times to repeat the value, infinite if not specified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable with a single item that is repeated over the specified times.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.sequenceEqual.html b/docs/functions/asynciterable.sequenceEqual.html index 0d96fd2c..ff549320 100644 --- a/docs/functions/asynciterable.sequenceEqual.html +++ b/docs/functions/asynciterable.sequenceEqual.html @@ -1,8 +1,140 @@ -sequenceEqual | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function sequenceEqual

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • sequenceEqual<T>(source, other, options?): Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Determines whether two sequences are equal by comparing the elements pairwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First async-iterable sequence to compare.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • other: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable sequence to compare.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: SequencEqualOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The sequence equal options which include an optional comparer and optional abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise which indicates whether both sequences are of equal length and their +sequenceEqual | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function sequenceEqual

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines whether two sequences are equal by comparing the elements pairwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First async-iterable sequence to compare.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        other: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable sequence to compare.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional options: SequencEqualOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The sequence equal options which include an optional comparer and optional abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A promise which indicates whether both sequences are of equal length and their corresponding elements are equal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.single.html b/docs/functions/asynciterable.single.html index 21472359..ea2290f1 100644 --- a/docs/functions/asynciterable.single.html +++ b/docs/functions/asynciterable.single.html @@ -1,10 +1,138 @@ -single | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function single

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • single<T>(source, options?): Promise<T | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the only element of an async-iterable sequence that matches the predicate if specified, +single | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function single

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns the only element of an async-iterable sequence that matches the predicate if specified, or undefined if no such element exists; this method reports an exception if there is more than one element in the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional options: OptionalFindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The optional options which includes a predicate for filtering, +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Source async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional options: OptionalFindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The optional options which includes a predicate for filtering, thisArg for predicate binding and an abort signal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Promise<T | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A promise with the single element in the async-iterable sequence that satisfies +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<T | undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise with the single element in the async-iterable sequence that satisfies the condition in the predicate, or undefined if no such element exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.some.html b/docs/functions/asynciterable.some.html index f1173a89..896cc99e 100644 --- a/docs/functions/asynciterable.some.html +++ b/docs/functions/asynciterable.some.html @@ -1,8 +1,136 @@ -some | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function some

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • some<T>(source, options): Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Determines whether any element of an async-iterable sequence satisfies a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: FindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which includes a required predicate, an optional +some | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function some

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines whether any element of an async-iterable sequence satisfies a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An async-iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options: FindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The options which includes a required predicate, an optional thisArg for binding, and an abort signal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A promise with a boolean determining whether any elements in the source sequence +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise with a boolean determining whether any elements in the source sequence pass the test in the specified predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.sum.html b/docs/functions/asynciterable.sum.html index be56083d..59690cd5 100644 --- a/docs/functions/asynciterable.sum.html +++ b/docs/functions/asynciterable.sum.html @@ -1,10 +1,156 @@ -sum | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function sum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • sum(source, options?): Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Computes the sum of a sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A sequence of values to calculate the sum.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: MathOptions<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options for providing a selector, thisArg and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing the sum of the sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • sum<T>(source, options?): Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Computes the sum of a sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of values in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A sequence of values to calculate the sum.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: MathOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options for providing a selector, thisArg and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing the sum of the sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +sum | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function sum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Computes the sum of a sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A sequence of values to calculate the sum.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: MathOptions<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options for providing a selector, thisArg and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing the sum of the sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Computes the sum of a sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of values in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A sequence of values to calculate the sum.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: MathOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options for providing a selector, thisArg and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing the sum of the sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.toArray.html b/docs/functions/asynciterable.toArray.html index 64e07b8a..826339e3 100644 --- a/docs/functions/asynciterable.toArray.html +++ b/docs/functions/asynciterable.toArray.html @@ -1,6 +1,134 @@ -toArray | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toArray<TSource>(source, signal?): Promise<TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts an existing async-iterable to a promise containing the array of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence to convert to an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An optional abort signal to cancel the operation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing all the items from the source sequence as an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +toArray | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an existing async-iterable to a promise containing the array of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence to convert to an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An optional abort signal to cancel the operation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing all the items from the source sequence as an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.toDOMStream.html b/docs/functions/asynciterable.toDOMStream.html index 428eb853..62842c68 100644 --- a/docs/functions/asynciterable.toDOMStream.html +++ b/docs/functions/asynciterable.toDOMStream.html @@ -1,10 +1,182 @@ -toDOMStream | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStream<T>(source, strategy?): ReadableStream<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts an async-iterable instance to a DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source async-iterable to convert to a DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional strategy: QueuingStrategy<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The queueing strategy to apply to the DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStream<T>(source, options): ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts an async-iterable stream to a DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable stream to convert to a DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: ReadableBYOBStreamOptions<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The ReadableBYOBStreamOptions to apply to the DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStream<T>(source, options): ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts an async-iterable stream to a DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable stream to convert to a DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: ReadableByteStreamOptions<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The ReadableByteStreamOptions to apply to the DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +toDOMStream | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an async-iterable instance to a DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source async-iterable to convert to a DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional strategy: QueuingStrategy<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The queueing strategy to apply to the DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an async-iterable stream to a DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable stream to convert to a DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ReadableBYOBStreamOptions<Uint8Array>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The ReadableBYOBStreamOptions to apply to the DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an async-iterable stream to a DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable stream to convert to a DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ReadableByteStreamOptions<Uint8Array>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The ReadableByteStreamOptions to apply to the DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.toDOMStreamProto.html b/docs/functions/asynciterable.toDOMStreamProto.html deleted file mode 100644 index 7f474df2..00000000 --- a/docs/functions/asynciterable.toDOMStreamProto.html +++ /dev/null @@ -1 +0,0 @@ -toDOMStreamProto | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toDOMStreamProto

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStreamProto<T>(this, options): ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: ReadableBYOBStreamOptions<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStreamProto<T>(this, options): ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: ReadableByteStreamOptions<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.toMap.html b/docs/functions/asynciterable.toMap.html index 381a314a..3c342a79 100644 --- a/docs/functions/asynciterable.toMap.html +++ b/docs/functions/asynciterable.toMap.html @@ -1,6 +1,141 @@ -toMap | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toMap<TSource, TKey, TElement>(source, options?): Promise<Map<TKey, TElement | TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts an async-iterable to a map with a key selector and options for an element selector and cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source collection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of key used for the map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TElement = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of element to use for the map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source collection to turn into a map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: ToMapOptions<TSource, TKey, TElement>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<Map<TKey, TElement | TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +toMap | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an async-iterable to a map with a key selector and options for an element selector and cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source collection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of key used for the map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TElement = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of element to use for the map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source collection to turn into a map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: ToMapOptions<TSource, TKey, TElement>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<Map<TKey, TElement | TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.toObservable.html b/docs/functions/asynciterable.toObservable.html index 2b372142..0c833ee0 100644 --- a/docs/functions/asynciterable.toObservable.html +++ b/docs/functions/asynciterable.toObservable.html @@ -1,5 +1,129 @@ -toObservable | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toObservable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toObservable<TSource>(source): Observable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts the async-iterable sequence to an observable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable to convert to an observable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Observable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The observable containing the elements from the async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +toObservable | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toObservable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts the async-iterable sequence to an observable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable to convert to an observable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Observable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The observable containing the elements from the async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.toSet.html b/docs/functions/asynciterable.toSet.html index f5e0fc5c..53c1cbcf 100644 --- a/docs/functions/asynciterable.toSet.html +++ b/docs/functions/asynciterable.toSet.html @@ -1,6 +1,134 @@ -toSet | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toSet<TSource>(source, signal?): Promise<Set<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts the existing async-iterable into a promise which resolves a Set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable to convert into a set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An optional abort signal to cancel the operation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<Set<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise which contains a Set with all the elements from the async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +toSet | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts the existing async-iterable into a promise which resolves a Set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable to convert into a set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An optional abort signal to cancel the operation at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<Set<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise which contains a Set with all the elements from the async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable.zip.html b/docs/functions/asynciterable.zip.html index 94f5ed0a..13f72992 100644 --- a/docs/functions/asynciterable.zip.html +++ b/docs/functions/asynciterable.zip.html @@ -1,55 +1,404 @@ -zip | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function zip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2>(source, source2): AsyncIterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3>(source, source2, source3): AsyncIterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3, T4>(source, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3, T4, T5>(source, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3, T4, T5, T6>(source, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T>(...sources): AsyncIterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...sources: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +zip | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function zip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.batch.html b/docs/functions/asynciterable_operators.batch.html index d4061048..3cf5bb0a 100644 --- a/docs/functions/asynciterable_operators.batch.html +++ b/docs/functions/asynciterable_operators.batch.html @@ -1,13 +1,142 @@ -batch | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function batch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • batch<TSource>(): OperatorAsyncFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns an async iterable sequence of batches that are collected from the source sequence between

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +batch | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function batch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns an async iterable sequence of batches that are collected from the source sequence between

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • subsequent next() calls.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source sequence. +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of elements in the source sequence. *

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns OperatorAsyncFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An operator returning an async-iterable of batches that are collection from the

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An operator returning an async-iterable of batches that are collection from the

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • source sequence between subsequent next() calls.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.buffer.html b/docs/functions/asynciterable_operators.buffer.html index a41c606f..a67319a4 100644 --- a/docs/functions/asynciterable_operators.buffer.html +++ b/docs/functions/asynciterable_operators.buffer.html @@ -1,8 +1,148 @@ -buffer | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • buffer<TSource>(count, skip?): OperatorAsyncFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Projects each element of an async-iterable sequence into consecutive non-overlapping +buffer | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Projects each element of an async-iterable sequence into consecutive non-overlapping buffers which are produced based on element count information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • count: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The length of each buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional skip: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An optional number of elements to skip between creation of consecutive buffers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator which returns anm async-iterable sequence with +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The length of each buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional skip: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An optional number of elements to skip between creation of consecutive buffers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which returns anm async-iterable sequence with consecutive non-overlapping buffers based upon element count information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.bufferCountOrTime.html b/docs/functions/asynciterable_operators.bufferCountOrTime.html index 6154916b..546df06e 100644 --- a/docs/functions/asynciterable_operators.bufferCountOrTime.html +++ b/docs/functions/asynciterable_operators.bufferCountOrTime.html @@ -1,8 +1,148 @@ -bufferCountOrTime | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function bufferCountOrTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bufferCountOrTime<TSource>(count, time): OperatorAsyncFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Projects each element of an async-iterable sequence into consecutive buffers +bufferCountOrTime | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function bufferCountOrTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Projects each element of an async-iterable sequence into consecutive buffers which are emitted when either the threshold count or time is met.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • count: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The size of the buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • time: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The threshold number of milliseconds to wait before flushing a non-full buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator which returns an async-iterable sequence +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The size of the buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      time: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The threshold number of milliseconds to wait before flushing a non-full buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which returns an async-iterable sequence of buffers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.catchError.html b/docs/functions/asynciterable_operators.catchError.html index 4f8c94fb..4e70c927 100644 --- a/docs/functions/asynciterable_operators.catchError.html +++ b/docs/functions/asynciterable_operators.catchError.html @@ -1,8 +1,161 @@ -catchError | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function catchError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • catchError<TSource, TResult>(handler): OperatorAsyncFunction<TSource, TSource | TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Continues an async-iterable sequence that is terminated by an exception with the +catchError | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function catchError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Continues an async-iterable sequence that is terminated by an exception with the async-iterable sequence produced by the handler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements from the handler function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • handler: ((error, signal?) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Error handler function, producing another async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (error, signal?): AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • error: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, TSource | TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator which continues an async-iterable sequence that is terminated by +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements from the handler function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      handler: ((error, signal?) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Error handler function, producing another async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (error, signal?): AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            error: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, TSource | TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which continues an async-iterable sequence that is terminated by an exception with the specified handler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.combineLatestWith.html b/docs/functions/asynciterable_operators.combineLatestWith.html index 93a4eb2a..6ed9bc1e 100644 --- a/docs/functions/asynciterable_operators.combineLatestWith.html +++ b/docs/functions/asynciterable_operators.combineLatestWith.html @@ -1,56 +1,397 @@ -combineLatestWith | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function combineLatestWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • combineLatestWith<T, T2>(source2): OperatorAsyncFunction<T, [T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +combineLatestWith | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function combineLatestWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • combineLatestWith<T, T2, T3>(source2, source3): OperatorAsyncFunction<T, [T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • combineLatestWith<T, T2, T3, T4>(source2, source3, source4): OperatorAsyncFunction<T, [T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • combineLatestWith<T, T2, T3, T4, T5>(source2, source3, source4, source5): OperatorAsyncFunction<T, [T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • combineLatestWith<T, T2, T3, T4, T5, T6>(source2, source3, source4, source5, source6): OperatorAsyncFunction<T, [T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • combineLatestWith<T>(...sources): OperatorAsyncFunction<T, T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence as an array whenever one of the async-iterable sequences produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Rest ...sources: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The async-iterable sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence containing an array of all sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.concatAll.html b/docs/functions/asynciterable_operators.concatAll.html index 04029e72..1c4acc98 100644 --- a/docs/functions/asynciterable_operators.concatAll.html +++ b/docs/functions/asynciterable_operators.concatAll.html @@ -1,5 +1,134 @@ -concatAll | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function concatAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concatAll<T>(): OperatorAsyncFunction<AsyncIterable<T>, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates all inner async-iterable sequences, as long as the previous +concatAll | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function concatAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates all inner async-iterable sequences, as long as the previous async-iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<AsyncIterable<T>, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator which concatenates all inner async-iterable sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<AsyncIterable<T>, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which concatenates all inner async-iterable sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.concatMap.html b/docs/functions/asynciterable_operators.concatMap.html index 7e039b7b..161c726f 100644 --- a/docs/functions/asynciterable_operators.concatMap.html +++ b/docs/functions/asynciterable_operators.concatMap.html @@ -1,9 +1,153 @@ -concatMap | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function concatMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concatMap<TSource, TResult>(selector, thisArg?): OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Projects each element of an async-iterable sequence to an async-iterable sequence and merges +concatMap | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function concatMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Projects each element of an async-iterable sequence to an async-iterable sequence and merges the resulting async-iterable sequences into one async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the projected inner sequences and the elements in the merged result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • selector: FlattenConcurrentSelector<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A transform function to apply to each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional thisArg: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Option this for binding to the selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator that creates an async-iterable sequence whose +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the projected inner sequences and the elements in the merged result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selector: FlattenConcurrentSelector<TSource, TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A transform function to apply to each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional thisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Option this for binding to the selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that creates an async-iterable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.concatWith.html b/docs/functions/asynciterable_operators.concatWith.html index 73de67d4..4e096406 100644 --- a/docs/functions/asynciterable_operators.concatWith.html +++ b/docs/functions/asynciterable_operators.concatWith.html @@ -1,55 +1,375 @@ -concatWith | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function concatWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concatWith<T, T2>(v2): OperatorAsyncFunction<T, T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates the second async-iterable sequence to the first async-iterable sequence upon successful termination of the first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains the elements of the first sequence, +concatWith | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function concatWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates the second async-iterable sequence to the first async-iterable sequence upon successful termination of the first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements of the first sequence, followed by those of the second the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • concatWith<T, T2, T3>(v2, v3): OperatorAsyncFunction<T, T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements of each given sequence, +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concatWith<T, T2, T3, T4>(v2, v3, v4): OperatorAsyncFunction<T, T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains the elements of each +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • concatWith<T, T2, T3, T4, T5>(v2, v3, v4, v5): OperatorAsyncFunction<T, T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence that contains the elements of each +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • concatWith<T, T2, T3, T4, T5, T6>(v2, v3, v4, v5, v6): OperatorAsyncFunction<T, T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Concatenates all async-iterable sequences in the given sequences, as long as the previous async-iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence that contains the elements of each + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.debounce.html b/docs/functions/asynciterable_operators.debounce.html index d588ec63..64175682 100644 --- a/docs/functions/asynciterable_operators.debounce.html +++ b/docs/functions/asynciterable_operators.debounce.html @@ -1,6 +1,142 @@ -debounce | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function debounce

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • debounce<TSource>(time): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Emits a notification from the source async-iterable only after a particular time span +debounce | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function debounce

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Emits a notification from the source async-iterable only after a particular time span has passed without another source emission.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • time: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The timeout duration in milliseconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator function which debounces by the given timeout.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      time: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The timeout duration in milliseconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator function which debounces by the given timeout.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.defaultIfEmpty.html b/docs/functions/asynciterable_operators.defaultIfEmpty.html index 92502165..71eff197 100644 --- a/docs/functions/asynciterable_operators.defaultIfEmpty.html +++ b/docs/functions/asynciterable_operators.defaultIfEmpty.html @@ -1,6 +1,142 @@ -defaultIfEmpty | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function defaultIfEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • defaultIfEmpty<T>(defaultValue): MonoTypeOperatorAsyncFunction<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the elements of the specified sequence or the default value in a singleton sequence +defaultIfEmpty | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function defaultIfEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns the elements of the specified sequence or the default value in a singleton sequence if the sequence is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • defaultValue: T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The value to return if the sequence is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator which returns the elements of the source sequence or the default value as a singleton.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaultValue: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to return if the sequence is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which returns the elements of the source sequence or the default value as a singleton.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.delay.html b/docs/functions/asynciterable_operators.delay.html index e0691e5c..06e367f5 100644 --- a/docs/functions/asynciterable_operators.delay.html +++ b/docs/functions/asynciterable_operators.delay.html @@ -1,5 +1,141 @@ -delay | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function delay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • delay<TSource>(dueTime): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Delays the emitting of the first item in the async-iterable by the given due time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • dueTime: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The delay duration in milliseconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which delays the before the iteration begins.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +delay | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function delay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Delays the emitting of the first item in the async-iterable by the given due time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dueTime: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The delay duration in milliseconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which delays the before the iteration begins.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.delayEach.html b/docs/functions/asynciterable_operators.delayEach.html index 65a16b2f..44042592 100644 --- a/docs/functions/asynciterable_operators.delayEach.html +++ b/docs/functions/asynciterable_operators.delayEach.html @@ -1,5 +1,141 @@ -delayEach | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function delayEach

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • delayEach<TSource>(dueTime): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Delays the emitting of each items in the async-iterable by the given due time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • dueTime: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The delay duration in milliseconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which takes an async-iterable and delays each item in the sequence by the given time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +delayEach | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function delayEach

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Delays the emitting of each items in the async-iterable by the given due time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dueTime: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The delay duration in milliseconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which takes an async-iterable and delays each item in the sequence by the given time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.distinct.html b/docs/functions/asynciterable_operators.distinct.html index e0b1b75b..c0c66488 100644 --- a/docs/functions/asynciterable_operators.distinct.html +++ b/docs/functions/asynciterable_operators.distinct.html @@ -1,6 +1,146 @@ -distinct | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function distinct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • distinct<TSource, TKey>(options?): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns an async-iterable sequence that contains only distinct elements according to the keySelector and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the discriminator key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: DistinctOptions<TSource, TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The optional arguments for a key selector and comparer function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns distinct elements according to the keySelector and options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +distinct | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function distinct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns an async-iterable sequence that contains only distinct elements according to the keySelector and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TKey = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the discriminator key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: DistinctOptions<TSource, TKey>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The optional arguments for a key selector and comparer function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns distinct elements according to the keySelector and options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.distinctUntilChanged.html b/docs/functions/asynciterable_operators.distinctUntilChanged.html index cbd53e9f..8669e578 100644 --- a/docs/functions/asynciterable_operators.distinctUntilChanged.html +++ b/docs/functions/asynciterable_operators.distinctUntilChanged.html @@ -1,6 +1,146 @@ -distinctUntilChanged | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function distinctUntilChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • distinctUntilChanged<TSource, TKey>(options?): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns an async-iterable sequence that contains only distinct contiguous elements according to the optional keySelector and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the discriminator key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: DistinctOptions<TSource, TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The optional options for adding a key selector and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns an async-iterable that contains only distinct contiguous items.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +distinctUntilChanged | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function distinctUntilChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns an async-iterable sequence that contains only distinct contiguous elements according to the optional keySelector and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TKey = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the discriminator key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: DistinctOptions<TSource, TKey>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The optional options for adding a key selector and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns an async-iterable that contains only distinct contiguous items.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.doWhile.html b/docs/functions/asynciterable_operators.doWhile.html index 200f0de9..58022d06 100644 --- a/docs/functions/asynciterable_operators.doWhile.html +++ b/docs/functions/asynciterable_operators.doWhile.html @@ -1,6 +1,153 @@ -doWhile | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function doWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • doWhile<TSource>(condition): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Generates an async-iterable sequence by repeating a source sequence as long as the given loop postcondition holds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • condition: ((signal?) => boolean | Promise<boolean>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Loop condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (signal?): boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that generates an async-iterable by repeating a +doWhile | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function doWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Generates an async-iterable sequence by repeating a source sequence as long as the given loop postcondition holds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        condition: ((signal?) => boolean | Promise<boolean>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Loop condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (signal?): boolean | Promise<boolean>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator that generates an async-iterable by repeating a source sequence while the postcondition holds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.endWith.html b/docs/functions/asynciterable_operators.endWith.html index c0b981fb..89066e06 100644 --- a/docs/functions/asynciterable_operators.endWith.html +++ b/docs/functions/asynciterable_operators.endWith.html @@ -1,5 +1,141 @@ -endWith | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function endWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • endWith<TSource>(...args): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Append values to an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...args: TSource[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The values to append to the end of the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which appends values to the end of the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +endWith | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function endWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Append values to an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...args: TSource[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The values to append to the end of the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which appends values to the end of the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.except.html b/docs/functions/asynciterable_operators.except.html index 2f9bd199..4d238b5a 100644 --- a/docs/functions/asynciterable_operators.except.html +++ b/docs/functions/asynciterable_operators.except.html @@ -1,8 +1,161 @@ -except | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function except

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • except<TSource>(second, comparer?): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Produces the set difference of two async-iterable sequences by using the specified equality comparer to compare values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of the input sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • second: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence whose elements that also occur in the +except | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function except

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Produces the set difference of two async-iterable sequences by using the specified equality comparer to compare values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements of the input sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          second: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An async-iterable sequence whose elements that also occur in the operator sequence will cause those elements to be removed from the returned sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optional comparer: ((x, y) => boolean | Promise<boolean>) = comparerAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An equality comparer to compare values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (x, y): boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • x: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • y: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An operator that returns a sequence that contains the set +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional comparer: ((x, y) => boolean | Promise<boolean>) = comparerAsync
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An equality comparer to compare values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (x, y): boolean | Promise<boolean>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            x: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            y: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns a sequence that contains the set difference of the elements of two sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.expand.html b/docs/functions/asynciterable_operators.expand.html index 854b0066..6fc2e7a9 100644 --- a/docs/functions/asynciterable_operators.expand.html +++ b/docs/functions/asynciterable_operators.expand.html @@ -1,6 +1,155 @@ -expand | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function expand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • expand<TSource>(selector): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Expands (breadth first) the async-iterable sequence by recursively applying a selector function to generate more sequences at each recursion level.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • selector: ((value, signal?) => AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Selector function to retrieve the next sequence to expand.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which returns a sequence with results +expand | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function expand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Expands (breadth first) the async-iterable sequence by recursively applying a selector function to generate more sequences at each recursion level.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        selector: ((value, signal?) => AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Selector function to retrieve the next sequence to expand.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, signal?): AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator which returns a sequence with results from the recursive expansion of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.filter.html b/docs/functions/asynciterable_operators.filter.html index c39722ea..404a3f46 100644 --- a/docs/functions/asynciterable_operators.filter.html +++ b/docs/functions/asynciterable_operators.filter.html @@ -1,13 +1,202 @@ -filter | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • filter<T, S>(predicate, thisArg?): OperatorAsyncFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Filters the elements of an async-iterable sequence based on a predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • predicate: ((value, index) => value is S)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to test each source element +filter | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Filters the elements of an async-iterable sequence based on a predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          predicate: ((value, index) => value is S)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to test each source element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, index): value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optional thisArg: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional this for binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns OperatorAsyncFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An operator which returns an async-iterable +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index): value is S
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional thisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional this for binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which returns an async-iterable sequence that contains elements from the input sequence that satisfy the condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • filter<T>(predicate, thisArg?): OperatorAsyncFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Filters the elements of an async-iterable sequence based on a predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • predicate: ((value, index) => boolean | Promise<boolean>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to test each source element + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Filters the elements of an async-iterable sequence based on a predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        predicate: ((value, index) => boolean | Promise<boolean>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to test each source element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, index): boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional thisArg: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional this for binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator which returns an async-iterable +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • (value, index): boolean | Promise<boolean>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Optional thisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Optional this for binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An operator which returns an async-iterable sequence that contains elements from the input sequence that satisfy the condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.finalize.html b/docs/functions/asynciterable_operators.finalize.html index bc05c015..bae7940b 100644 --- a/docs/functions/asynciterable_operators.finalize.html +++ b/docs/functions/asynciterable_operators.finalize.html @@ -1,6 +1,148 @@ -finalize | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function finalize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • finalize<TSource>(action): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Invokes a specified asynchronous action after the source async-iterable sequence terminates gracefully or exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • action: (() => void | Promise<void>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Action to invoke and await asynchronously after the source async-iterable sequence terminates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (): void | Promise<void>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns void | Promise<void>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns the source sequence with the +finalize | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function finalize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Invokes a specified asynchronous action after the source async-iterable sequence terminates gracefully or exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        action: (() => void | Promise<void>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Action to invoke and await asynchronously after the source async-iterable sequence terminates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (): void | Promise<void>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns void | Promise<void>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator that returns the source sequence with the action-invoking termination behavior applied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.flat.html b/docs/functions/asynciterable_operators.flat.html index 5156890e..08830b41 100644 --- a/docs/functions/asynciterable_operators.flat.html +++ b/docs/functions/asynciterable_operators.flat.html @@ -1,4 +1,156 @@ -flat | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function flat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • flat<D>(depth?, concurrent?): (<T>(source) => AsyncIterable<Flattened<T, D>>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Flattens the nested async-iterable by the given depth.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • D extends number = -1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional depth: D = ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The depth to flatten the async-iterable sequence if specified, otherwise infinite.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • concurrent: number = Infinity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns (<T>(source) => AsyncIterable<Flattened<T, D>>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that flattens the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • <T>(source): AsyncIterable<Flattened<T, D>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • source: AsyncIterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns AsyncIterable<Flattened<T, D>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +flat | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function flat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Flattens the nested async-iterable by the given depth.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      D extends number = -1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional depth: D = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The depth to flatten the async-iterable sequence if specified, otherwise infinite.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      concurrent: number = Infinity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns (<T>(source) => AsyncIterable<Flattened<T, D>>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that flattens the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • <T>(source): AsyncIterable<Flattened<T, D>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns AsyncIterable<Flattened<T, D>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.flatMap.html b/docs/functions/asynciterable_operators.flatMap.html index f1d93d18..15c3abc8 100644 --- a/docs/functions/asynciterable_operators.flatMap.html +++ b/docs/functions/asynciterable_operators.flatMap.html @@ -1,9 +1,155 @@ -flatMap | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function flatMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • flatMap<TSource, TResult>(selector, concurrent?, thisArg?): OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Projects each element of an async-iterable sequence to an async-iterable sequence and merges +flatMap | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function flatMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Projects each element of an async-iterable sequence to an async-iterable sequence and merges the resulting async-iterable sequences into one async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the projected inner sequences and the elements in the merged result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • selector: FlattenConcurrentSelector<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A transform function to apply to each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • concurrent: number = Infinity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional thisArg: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Option this for binding to the selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator that creates an async-iterable sequence whose +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the projected inner sequences and the elements in the merged result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selector: FlattenConcurrentSelector<TSource, TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A transform function to apply to each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      concurrent: number = Infinity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional thisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Option this for binding to the selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that creates an async-iterable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.groupBy.html b/docs/functions/asynciterable_operators.groupBy.html index 5c68198d..5d149c54 100644 --- a/docs/functions/asynciterable_operators.groupBy.html +++ b/docs/functions/asynciterable_operators.groupBy.html @@ -1,15 +1,227 @@ -groupBy | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function groupBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • groupBy<TSource, TKey>(keySelector): OperatorAsyncFunction<TSource, GroupedAsyncIterable<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Groups the elements of an async-iterable sequence and selects the resulting elements by using a specified function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the grouping key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • keySelector: ((value, signal?) => TKey | Promise<TKey>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to extract the key for each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, GroupedAsyncIterable<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A sequence of async-iterable groups, each of which corresponds to a unique key value, +groupBy | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function groupBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Groups the elements of an async-iterable sequence and selects the resulting elements by using a specified function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the grouping key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keySelector: ((value, signal?) => TKey | Promise<TKey>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to extract the key for each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, signal?): TKey | Promise<TKey>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, GroupedAsyncIterable<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A sequence of async-iterable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • groupBy<TSource, TKey, TValue>(keySelector, elementSelector?): OperatorAsyncFunction<TSource, GroupedAsyncIterable<TKey, TValue>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Groups the elements of an async-iterable sequence and selects the resulting elements by using a specified function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the grouping key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements within the groups computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • keySelector: ((value, signal?) => TKey | Promise<TKey>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to extract the key for each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, signal?): TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional elementSelector: ((value, signal?) => TValue | Promise<TValue>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to map each source element to an element in an async-enumerable group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, signal?): TValue | Promise<TValue>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TValue | Promise<TValue>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, GroupedAsyncIterable<TKey, TValue>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A sequence of async-iterable groups, each of which corresponds to a unique key value, + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Groups the elements of an async-iterable sequence and selects the resulting elements by using a specified function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the grouping key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements within the groups computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keySelector: ((value, signal?) => TKey | Promise<TKey>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to extract the key for each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, signal?): TKey | Promise<TKey>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional elementSelector: ((value, signal?) => TValue | Promise<TValue>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to map each source element to an element in an async-enumerable group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, signal?): TValue | Promise<TValue>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TValue | Promise<TValue>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, GroupedAsyncIterable<TKey, TValue>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A sequence of async-iterable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.groupJoin.html b/docs/functions/asynciterable_operators.groupJoin.html index 2a0a08e4..3afe7654 100644 --- a/docs/functions/asynciterable_operators.groupJoin.html +++ b/docs/functions/asynciterable_operators.groupJoin.html @@ -1,15 +1,216 @@ -groupJoin | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function groupJoin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • groupJoin<TOuter, TInner, TKey, TResult>(inner, outerSelector, innerSelector, resultSelector): OperatorAsyncFunction<TOuter, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Correlates the elements of two async-iterable sequences based on equality of keys and groups the results.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TOuter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TInner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the keys returned by the key selector functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the result elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • inner: AsyncIterable<TInner>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-enumerable sequence to join to the first sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • outerSelector: ((value, signal?) => TKey | Promise<TKey>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to extract the join key from each +groupJoin | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function groupJoin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Correlates the elements of two async-iterable sequences based on equality of keys and groups the results.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TOuter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TInner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the keys returned by the key selector functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the result elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inner: AsyncIterable<TInner>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The async-enumerable sequence to join to the first sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          outerSelector: ((value, signal?) => TKey | Promise<TKey>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to extract the join key from each element of the first sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TOuter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • innerSelector: ((value, signal?) => TKey | Promise<TKey>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to extract the join key from each +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TKey | Promise<TKey>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TOuter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          innerSelector: ((value, signal?) => TKey | Promise<TKey>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to extract the join key from each element of the second sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TInner
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • resultSelector: ((outer, inner, signal?) => TResult | Promise<TResult>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to create a result element from an element from the first sequence and a +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TKey | Promise<TKey>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TInner
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resultSelector: ((outer, inner, signal?) => TResult | Promise<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to create a result element from an element from the first sequence and a collection of matching elements from the second sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (outer, inner, signal?): TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • outer: TOuter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • inner: AsyncIterable<TInner>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns OperatorAsyncFunction<TOuter, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An operator that returns an async-iterable sequence that contains the result elements +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (outer, inner, signal?): TResult | Promise<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            outer: TOuter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            inner: AsyncIterable<TInner>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TOuter, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns an async-iterable sequence that contains the result elements that are obtained by performing a grouped join on two sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.ignoreElements.html b/docs/functions/asynciterable_operators.ignoreElements.html index 40fa829a..e330348e 100644 --- a/docs/functions/asynciterable_operators.ignoreElements.html +++ b/docs/functions/asynciterable_operators.ignoreElements.html @@ -1,5 +1,134 @@ -ignoreElements | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function ignoreElements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ignoreElements<TSource>(): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Ignores all elements in an async-iterable sequence leaving only the termination messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns an empty async-iterable sequence +ignoreElements | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function ignoreElements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Ignores all elements in an async-iterable sequence leaving only the termination messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator that returns an empty async-iterable sequence that signals termination, successful or exceptional, of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.innerJoin.html b/docs/functions/asynciterable_operators.innerJoin.html index 65145cfe..b9c5140d 100644 --- a/docs/functions/asynciterable_operators.innerJoin.html +++ b/docs/functions/asynciterable_operators.innerJoin.html @@ -1,15 +1,216 @@ -innerJoin | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function innerJoin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • innerJoin<TOuter, TInner, TKey, TResult>(inner, outerSelector, innerSelector, resultSelector): OperatorAsyncFunction<TOuter, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Correlates the elements of two sequences based on matching keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TOuter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TInner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the keys returned by the key selector functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the result elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • inner: AsyncIterable<TInner>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-enumerable sequence to join to the first sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • outerSelector: ((value, signal?) => TKey | Promise<TKey>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to extract the join key from each element +innerJoin | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function innerJoin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Correlates the elements of two sequences based on matching keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TOuter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TInner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the keys returned by the key selector functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the result elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inner: AsyncIterable<TInner>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The async-enumerable sequence to join to the first sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          outerSelector: ((value, signal?) => TKey | Promise<TKey>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to extract the join key from each element of the first sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TOuter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • innerSelector: ((value, signal?) => TKey | Promise<TKey>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to extract the join key from each element +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TKey | Promise<TKey>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TOuter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          innerSelector: ((value, signal?) => TKey | Promise<TKey>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to extract the join key from each element of the second sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TInner
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • resultSelector: ((outer, inner, signal?) => TResult | Promise<TResult>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to create a result element +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): TKey | Promise<TKey>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TInner
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey | Promise<TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resultSelector: ((outer, inner, signal?) => TResult | Promise<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to create a result element from two matching elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (outer, inner, signal?): TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • outer: TOuter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • inner: TInner
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns OperatorAsyncFunction<TOuter, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An async-iterable sequence that has elements that are obtained by performing an inner join +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (outer, inner, signal?): TResult | Promise<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            outer: TOuter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            inner: TInner
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TOuter, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that has elements that are obtained by performing an inner join on two sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.intersect.html b/docs/functions/asynciterable_operators.intersect.html index ec66f790..6b60d434 100644 --- a/docs/functions/asynciterable_operators.intersect.html +++ b/docs/functions/asynciterable_operators.intersect.html @@ -1,8 +1,161 @@ -intersect | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function intersect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • intersect<TSource>(second, comparer?): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Produces the set intersection of two async-iterable sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of the input sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • second: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence whose distinct elements that also +intersect | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function intersect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Produces the set intersection of two async-iterable sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements of the input sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          second: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An async-iterable sequence whose distinct elements that also appear in the first sequence will be returned.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optional comparer: ((x, y) => boolean | Promise<boolean>) = comparerAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An equality comparer to compare values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (x, y): boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • x: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • y: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An operator that returns a sequence that contains the elements that form the set +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional comparer: ((x, y) => boolean | Promise<boolean>) = comparerAsync
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An equality comparer to compare values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (x, y): boolean | Promise<boolean>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            x: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            y: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns a sequence that contains the elements that form the set intersection of two sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.map.html b/docs/functions/asynciterable_operators.map.html index 0742c429..33c6c871 100644 --- a/docs/functions/asynciterable_operators.map.html +++ b/docs/functions/asynciterable_operators.map.html @@ -1,10 +1,169 @@ -map | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • map<TSource, TResult>(selector, thisArg?): OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Projects each element of an async-enumerable sequence into a new form.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the result sequence, obtained by running the selector +map | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Projects each element of an async-enumerable sequence into a new form.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • selector: ((value, index, signal?) => TResult | Promise<TResult>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A transform function +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        selector: ((value, index, signal?) => TResult | Promise<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A transform function to apply to each source element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, index, signal?): TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional thisArg: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional this for binding to the selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence whose elements are the result of invoking the transform +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index, signal?): TResult | Promise<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult | Promise<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional thisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional this for binding to the selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence whose elements are the result of invoking the transform function on each element of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.memoize.html b/docs/functions/asynciterable_operators.memoize.html index f9ed7b0b..493759d5 100644 --- a/docs/functions/asynciterable_operators.memoize.html +++ b/docs/functions/asynciterable_operators.memoize.html @@ -1,18 +1,194 @@ -memoize | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function memoize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • memoize<TSource>(readerCount?): OperatorAsyncFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates a buffer with a view over the source sequence, causing a specified number of iterators to obtain access +memoize | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function memoize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Creates a buffer with a view over the source sequence, causing a specified number of iterators to obtain access to all of the sequence's elements without causing multiple enumerations over the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional readerCount: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Number of iterators that can access the underlying buffer. +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional readerCount: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Number of iterators that can access the underlying buffer. Once every iterator has obtained an element from the buffer, the element is removed from the buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns OperatorAsyncFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Buffer enabling a specified number of iterators to retrieve all +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Buffer enabling a specified number of iterators to retrieve all elements from the shared source sequence, without duplicating source iteration side-effects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • memoize<TSource, TResult>(readerCount?, selector?): OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Memoizes the source sequence within a selector function where a specified number of iterators can get access + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Memoizes the source sequence within a selector function where a specified number of iterators can get access to all of the sequence's elements without causing multiple iterations over the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Result sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional readerCount: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Number of iterators that can access the underlying buffer. Once every +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Result sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional readerCount: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Number of iterators that can access the underlying buffer. Once every iterator has obtained an element from the buffer, the element is removed from the buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional selector: ((value) => AsyncIterable<TResult>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Selector function with memoized access +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional selector: ((value) => AsyncIterable<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Selector function with memoized access to the source sequence for a specified number of iterators.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value): AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sequence resulting from applying the selector function to the +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • (value): AsyncIterable<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Sequence resulting from applying the selector function to the memoized view over the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.mergeAll.html b/docs/functions/asynciterable_operators.mergeAll.html index 576bc03a..25cb74d7 100644 --- a/docs/functions/asynciterable_operators.mergeAll.html +++ b/docs/functions/asynciterable_operators.mergeAll.html @@ -1,3 +1,146 @@ -mergeAll | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function mergeAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • mergeAll(concurrent?): (<TSource>(source) => FlattenConcurrentAsyncIterable<AsyncIterable<TSource>, TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges elements from all inner async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • concurrent: number = Infinity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns (<TSource>(source) => FlattenConcurrentAsyncIterable<AsyncIterable<TSource>, TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The async-iterable sequence that merges the elements of the inner sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • <TSource>(source): FlattenConcurrentAsyncIterable<AsyncIterable<TSource>, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • source: AsyncIterable<AsyncIterable<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns FlattenConcurrentAsyncIterable<AsyncIterable<TSource>, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +mergeAll | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function mergeAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges elements from all inner async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      concurrent: number = Infinity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns (<TSource>(source) => FlattenConcurrentAsyncIterable<AsyncIterable<TSource>, TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The async-iterable sequence that merges the elements of the inner sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • <TSource>(source): FlattenConcurrentAsyncIterable<AsyncIterable<TSource>, TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          source: AsyncIterable<AsyncIterable<TSource>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns FlattenConcurrentAsyncIterable<AsyncIterable<TSource>, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.mergeWith.html b/docs/functions/asynciterable_operators.mergeWith.html index 144571b9..25b6c870 100644 --- a/docs/functions/asynciterable_operators.mergeWith.html +++ b/docs/functions/asynciterable_operators.mergeWith.html @@ -1,55 +1,400 @@ -mergeWith | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function mergeWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • mergeWith<T, T2>(v2): OperatorAsyncFunction<T, T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The merged elements from all of the specified async-iterable sequences +mergeWith | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function mergeWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mergeWith<T, T2, T3>(v2, v3): OperatorAsyncFunction<T, T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mergeWith<T, T2, T3, T4>(source, v2, v3, v4): OperatorAsyncFunction<T, T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mergeWith<T, T2, T3, T4, T5>(v2, v3, v4, v5): OperatorAsyncFunction<T, T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mergeWith<T, T2, T3, T4, T5, T6>(v2, v3, v4, v5, v6): OperatorAsyncFunction<T, T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The sixth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The sixth async-iterable source to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mergeWith<T>(source, ...args): OperatorAsyncFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the sequence to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Rest ...args: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The async-iterable sources to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sequence to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...args: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-iterable sources to merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The merged elements from all of the specified async-iterable sequences into a single async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.orderBy.html b/docs/functions/asynciterable_operators.orderBy.html index a68ab579..f3659f75 100644 --- a/docs/functions/asynciterable_operators.orderBy.html +++ b/docs/functions/asynciterable_operators.orderBy.html @@ -1,19 +1,187 @@ -orderBy | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function orderBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • orderBy<TKey, TSource>(keySelector, comparer?): UnaryFunction<AsyncIterable<TSource>, OrderedAsyncIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • /**

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +orderBy | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function orderBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Sorts the elements of a sequence in ascending order according to a key by using a specified comparer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements of source. +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements of source. *

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the key returned by keySelector. +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the key returned by keySelector. *

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • keySelector: ((item) => TKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to extract a key from an element. +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keySelector: ((item) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to extract a key from an element. *

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (item): TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • item: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional comparer: ((fst, snd) => number) = defaultSorter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A comparer to compare keys. +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (item): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              item: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional comparer: ((fst, snd) => number) = defaultSorter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A comparer to compare keys. *

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (fst, snd): number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • snd: TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns UnaryFunction<AsyncIterable<TSource>, OrderedAsyncIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An ordered async-iterable sequence whose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • (fst, snd): number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          snd: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns UnaryFunction<AsyncIterable<TSource>, OrderedAsyncIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An ordered async-iterable sequence whose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • elements are sorted according to a key and comparer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.orderByDescending.html b/docs/functions/asynciterable_operators.orderByDescending.html index ddba6d1d..e1d7f1dd 100644 --- a/docs/functions/asynciterable_operators.orderByDescending.html +++ b/docs/functions/asynciterable_operators.orderByDescending.html @@ -1,8 +1,176 @@ -orderByDescending | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function orderByDescending

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • orderByDescending<TKey, TSource>(keySelector, comparer?): UnaryFunction<AsyncIterable<TSource>, OrderedAsyncIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Sorts the elements of a sequence in descending order according to a key by using a specified comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the key returned by keySelector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • keySelector: ((item) => TKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to extract a key from an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (item): TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • item: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional comparer: ((fst, snd) => number) = defaultSorter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A comparer to compare keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (fst, snd): number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • snd: TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<AsyncIterable<TSource>, OrderedAsyncIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An ordered async-iterable sequence whose +orderByDescending | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function orderByDescending

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sorts the elements of a sequence in descending order according to a key by using a specified comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the key returned by keySelector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keySelector: ((item) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to extract a key from an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (item): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              item: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional comparer: ((fst, snd) => number) = defaultSorter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A comparer to compare keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (fst, snd): number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              snd: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns UnaryFunction<AsyncIterable<TSource>, OrderedAsyncIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An ordered async-iterable sequence whose elements are sorted in descending order according to a key and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.pairwise.html b/docs/functions/asynciterable_operators.pairwise.html index df7faf20..88380b5a 100644 --- a/docs/functions/asynciterable_operators.pairwise.html +++ b/docs/functions/asynciterable_operators.pairwise.html @@ -1,5 +1,134 @@ -pairwise | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function pairwise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • pairwise<TSource>(): OperatorAsyncFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns a sequence of each element in the input sequence and its predecessor, with the exception of the +pairwise | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function pairwise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns a sequence of each element in the input sequence and its predecessor, with the exception of the first element which is only returned as the predecessor of the second element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.pluck.html b/docs/functions/asynciterable_operators.pluck.html index 3ab5e370..608aaae4 100644 --- a/docs/functions/asynciterable_operators.pluck.html +++ b/docs/functions/asynciterable_operators.pluck.html @@ -1,6 +1,146 @@ -pluck | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function pluck

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • pluck<TSource, TResult>(...args): OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Maps each source value to its specified nested property.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the result sequence, obtained by the property names.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...args: string[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The nested properties to pluck from each source value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable of property values from the source values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +pluck | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function pluck

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Maps each source value to its specified nested property.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the result sequence, obtained by the property names.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...args: string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The nested properties to pluck from each source value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable of property values from the source values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.publish.html b/docs/functions/asynciterable_operators.publish.html index cf7ecfb3..660115e2 100644 --- a/docs/functions/asynciterable_operators.publish.html +++ b/docs/functions/asynciterable_operators.publish.html @@ -1,14 +1,179 @@ -publish | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function publish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • publish<TSource>(): OperatorAsyncFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates a buffer with a view over the source sequence, causing each iterator to obtain access to the +publish | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function publish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Creates a buffer with a view over the source sequence, causing each iterator to obtain access to the remainder of the sequence from the current index in the buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Buffer enabling each iterator to retrieve elements from +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Buffer enabling each iterator to retrieve elements from the shared source sequence, starting from the index at the point of obtaining the enumerator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • publish<TSource, TResult>(selector?): OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Buffer enabling each iterator to retrieve elements from the shared source sequence, starting from the + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Buffer enabling each iterator to retrieve elements from the shared source sequence, starting from the index at the point of obtaining the iterator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Result sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional selector: ((value) => AsyncIterable<TResult>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Selector function with published +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Result sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional selector: ((value) => AsyncIterable<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Selector function with published access to the source sequence for each iterator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value): AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sequence resulting from applying the selector function to the +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • (value): AsyncIterable<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns AsyncIterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Sequence resulting from applying the selector function to the published view over the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.raceWith.html b/docs/functions/asynciterable_operators.raceWith.html index 969adf8a..b9952515 100644 --- a/docs/functions/asynciterable_operators.raceWith.html +++ b/docs/functions/asynciterable_operators.raceWith.html @@ -1,4 +1,138 @@ -raceWith | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function raceWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • raceWith<TSource>(...sources): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Propagates the async sequence that reacts first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...sources: AsyncIterable<TSource>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async sequence that surfaces either of the given sequences, whichever reacted first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +raceWith | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function raceWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Propagates the async sequence that reacts first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: AsyncIterable<TSource>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async sequence that surfaces either of the given sequences, whichever reacted first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.repeat.html b/docs/functions/asynciterable_operators.repeat.html index ba9ebedf..c8b5979f 100644 --- a/docs/functions/asynciterable_operators.repeat.html +++ b/docs/functions/asynciterable_operators.repeat.html @@ -1,5 +1,141 @@ -repeat | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function repeat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repeat<TSource>(count?): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Repeats the async-enumerable sequence a specified number of times.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional count: number = -1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Number of times to repeat the sequence. If not specified, the sequence repeats indefinitely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The async-iterable sequence producing the elements of the given sequence repeatedly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +repeat | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function repeat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Repeats the async-enumerable sequence a specified number of times.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional count: number = -1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Number of times to repeat the sequence. If not specified, the sequence repeats indefinitely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The async-iterable sequence producing the elements of the given sequence repeatedly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.retry.html b/docs/functions/asynciterable_operators.retry.html index 6f83a4cd..d374b1f6 100644 --- a/docs/functions/asynciterable_operators.retry.html +++ b/docs/functions/asynciterable_operators.retry.html @@ -1,6 +1,142 @@ -retry | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function retry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • retry<TSource>(count?): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Retries the async-iterable instance the number of given times. If not supplied, it will try infinitely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional count: number = -1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An optional number of times to retry, otherwise is set to infinite retries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence producing the elements of the +retry | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function retry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Retries the async-iterable instance the number of given times. If not supplied, it will try infinitely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional count: number = -1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An optional number of times to retry, otherwise is set to infinite retries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence producing the elements of the given sequence repeatedly until it terminates successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.reverse.html b/docs/functions/asynciterable_operators.reverse.html index 47ec871e..9d78d541 100644 --- a/docs/functions/asynciterable_operators.reverse.html +++ b/docs/functions/asynciterable_operators.reverse.html @@ -1,4 +1,133 @@ -reverse | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • reverse<TSource>(): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Reverses the async-iterable instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The async-iterable in reversed sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +reverse | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Reverses the async-iterable instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The async-iterable in reversed sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.scan.html b/docs/functions/asynciterable_operators.scan.html index 08aef210..79c37b0e 100644 --- a/docs/functions/asynciterable_operators.scan.html +++ b/docs/functions/asynciterable_operators.scan.html @@ -1,7 +1,147 @@ -scan | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function scan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • scan<T, R>(options): OperatorAsyncFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Applies an accumulator function over an async-iterable sequence and returns each intermediate result. +scan | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function scan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Applies an accumulator function over an async-iterable sequence and returns each intermediate result. The specified seed value, if given, is used as the initial accumulator value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • options: ScanOptions<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The options including the accumulator function and seed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-enumerable sequence containing the accumulated values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ScanOptions<T, R>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options including the accumulator function and seed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-enumerable sequence containing the accumulated values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.scanRight.html b/docs/functions/asynciterable_operators.scanRight.html index f23491d2..11876f07 100644 --- a/docs/functions/asynciterable_operators.scanRight.html +++ b/docs/functions/asynciterable_operators.scanRight.html @@ -1,7 +1,147 @@ -scanRight | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function scanRight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • scanRight<T, R>(options): OperatorAsyncFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Applies an accumulator function over an async-iterable sequence from the right and returns each intermediate result. +scanRight | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function scanRight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Applies an accumulator function over an async-iterable sequence from the right and returns each intermediate result. The specified seed value, if given, is used as the initial accumulator value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • options: ScanOptions<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The options including the accumulator function and seed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-enumerable sequence containing the accumulated values from the right.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ScanOptions<T, R>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options including the accumulator function and seed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-enumerable sequence containing the accumulated values from the right.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.share.html b/docs/functions/asynciterable_operators.share.html index 21a6a78d..a573477c 100644 --- a/docs/functions/asynciterable_operators.share.html +++ b/docs/functions/asynciterable_operators.share.html @@ -1,13 +1,180 @@ -share | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function share

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • share<TSource>(): OperatorAsyncFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates a buffer with a shared view over the source sequence, causing each iterator to fetch the next element +share | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function share

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Creates a buffer with a shared view over the source sequence, causing each iterator to fetch the next element from the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Buffer enabling each enumerator to retrieve elements from the shared source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • share<TSource, TResult>(selector?): OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Shares the source sequence within a selector function where each iterator can fetch the next element from the +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Buffer enabling each enumerator to retrieve elements from the shared source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Shares the source sequence within a selector function where each iterator can fetch the next element from the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Result sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional selector: ((value, signal?) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Selector function with shared access +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Result sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional selector: ((value, signal?) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Selector function with shared access to the source sequence for each iterator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value, signal?): AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sequence resulting from applying the selector function to the +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, signal?): AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sequence resulting from applying the selector function to the shared view over the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.skip.html b/docs/functions/asynciterable_operators.skip.html index 64ac9c1b..f306a3a1 100644 --- a/docs/functions/asynciterable_operators.skip.html +++ b/docs/functions/asynciterable_operators.skip.html @@ -1,6 +1,142 @@ -skip | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skip<TSource>(count): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Bypasses a specified number of elements in an async-iterable sequence and then returns the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • count: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of elements to skip before returning the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains the elements that +skip | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Bypasses a specified number of elements in an async-iterable sequence and then returns the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The number of elements to skip before returning the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements that occur after the specified index in the input sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.skipLast.html b/docs/functions/asynciterable_operators.skipLast.html index 5415a467..1ab56efe 100644 --- a/docs/functions/asynciterable_operators.skipLast.html +++ b/docs/functions/asynciterable_operators.skipLast.html @@ -1,6 +1,142 @@ -skipLast | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function skipLast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skipLast<TSource>(count): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Bypasses a specified number of elements at the end of an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • count: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Number of elements to bypass at the end of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence containing the +skipLast | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function skipLast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Bypasses a specified number of elements at the end of an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Number of elements to bypass at the end of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing the source sequence elements except for the bypassed ones at the end.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.skipUntil.html b/docs/functions/asynciterable_operators.skipUntil.html index 660e9fa8..1e180ec2 100644 --- a/docs/functions/asynciterable_operators.skipUntil.html +++ b/docs/functions/asynciterable_operators.skipUntil.html @@ -1,7 +1,154 @@ -skipUntil | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function skipUntil

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skipUntil<TSource>(other): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the elements from the source observable sequence only after the function that returns a promise produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • other: ((signal?) => Promise<any>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function which returns a promise that triggers propagation +skipUntil | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function skipUntil

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns the elements from the source observable sequence only after the function that returns a promise produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          other: ((signal?) => Promise<any>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function which returns a promise that triggers propagation of elements of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (signal?): Promise<any>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns Promise<any>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An async-iterable sequence containing the elements of the source sequence +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (signal?): Promise<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns Promise<any>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence containing the elements of the source sequence starting from the point the function that returns a promise triggered propagation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.skipWhile.html b/docs/functions/asynciterable_operators.skipWhile.html index 68cac4b8..abc5de28 100644 --- a/docs/functions/asynciterable_operators.skipWhile.html +++ b/docs/functions/asynciterable_operators.skipWhile.html @@ -1,14 +1,205 @@ -skipWhile | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function skipWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skipWhile<T, S>(predicate): OperatorAsyncFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Bypasses elements in an async-iterale sequence as long as a specified condition is true +skipWhile | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function skipWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Bypasses elements in an async-iterale sequence as long as a specified condition is true and then returns the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The result of the predicate that is truthy/falsy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • predicate: ((value, index, signal?) => value is S)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, index, signal?): value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements from the input +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The result of the predicate that is truthy/falsy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      predicate: ((value, index, signal?) => value is S)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index, signal?): value is S
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skipWhile<T>(predicate): OperatorAsyncFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Bypasses elements in an async-iterale sequence as long as a specified condition is true + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bypasses elements in an async-iterale sequence as long as a specified condition is true and then returns the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • predicate: ((value, index, signal?) => boolean | Promise<boolean>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index, signal?): boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains the elements from the input +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    predicate: ((value, index, signal?) => boolean | Promise<boolean>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • (value, index, signal?): boolean | Promise<boolean>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.slice.html b/docs/functions/asynciterable_operators.slice.html index 701a4e32..78b25854 100644 --- a/docs/functions/asynciterable_operators.slice.html +++ b/docs/functions/asynciterable_operators.slice.html @@ -1,6 +1,146 @@ -slice | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function slice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • slice<TSource>(begin, end?): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the elements from the source async-iterable sequence only after the function that returns a promise produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • begin: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Zero-based index at which to begin extraction.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional end: number = Infinity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Zero-based index before which to end extraction.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable containing the extracted elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +slice | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function slice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the elements from the source async-iterable sequence only after the function that returns a promise produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      begin: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Zero-based index at which to begin extraction.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional end: number = Infinity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Zero-based index before which to end extraction.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable containing the extracted elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.startWith.html b/docs/functions/asynciterable_operators.startWith.html index 38957fa9..a65a74d5 100644 --- a/docs/functions/asynciterable_operators.startWith.html +++ b/docs/functions/asynciterable_operators.startWith.html @@ -1,5 +1,157 @@ -startWith | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function startWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • startWith<TSource>(...args): (<TInput>(source) => AsyncIterable<TInput | TSource[number & keyof TSource]>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Prepend a value to an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource extends any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...args: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Elements to prepend to the specified sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns (<TInput>(source) => AsyncIterable<TInput | TSource[number & keyof TSource]>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The source sequence prepended with the specified values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • <TInput>(source): AsyncIterable<TInput | TSource[number & keyof TSource]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • TInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • source: AsyncIterable<TInput>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns AsyncIterable<TInput | TSource[number & keyof TSource]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +startWith | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function startWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Prepend a value to an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource extends any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...args: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Elements to prepend to the specified sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns (<TInput>(source) => AsyncIterable<TInput | TSource[number & keyof TSource]>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The source sequence prepended with the specified values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • <TInput>(source): AsyncIterable<TInput | TSource[number & keyof TSource]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          source: AsyncIterable<TInput>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns AsyncIterable<TInput | TSource[number & keyof TSource]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.switchAll.html b/docs/functions/asynciterable_operators.switchAll.html index 2427342c..eff257ba 100644 --- a/docs/functions/asynciterable_operators.switchAll.html +++ b/docs/functions/asynciterable_operators.switchAll.html @@ -1,3 +1,141 @@ -switchAll | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function switchAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • switchAll(): (<TSource>(source) => FlattenConcurrentAsyncIterable<AsyncIterable<TSource>, TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges elements from all inner async-iterable sequences into a single async-iterable sequence, emitting values only from the most recently projected async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns (<TSource>(source) => FlattenConcurrentAsyncIterable<AsyncIterable<TSource>, TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The async-iterable sequence that merges the elements of the inner sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • <TSource>(source): FlattenConcurrentAsyncIterable<AsyncIterable<TSource>, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • source: AsyncIterable<AsyncIterable<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns FlattenConcurrentAsyncIterable<AsyncIterable<TSource>, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +switchAll | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function switchAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges elements from all inner async-iterable sequences into a single async-iterable sequence, emitting values only from the most recently projected async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns (<TSource>(source) => FlattenConcurrentAsyncIterable<AsyncIterable<TSource>, TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The async-iterable sequence that merges the elements of the inner sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • <TSource>(source): FlattenConcurrentAsyncIterable<AsyncIterable<TSource>, TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          source: AsyncIterable<AsyncIterable<TSource>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns FlattenConcurrentAsyncIterable<AsyncIterable<TSource>, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.switchMap.html b/docs/functions/asynciterable_operators.switchMap.html index f266253f..8633bbad 100644 --- a/docs/functions/asynciterable_operators.switchMap.html +++ b/docs/functions/asynciterable_operators.switchMap.html @@ -1,9 +1,153 @@ -switchMap | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function switchMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • switchMap<TSource, TResult>(selector, thisArg?): OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Projects each element of an async-iterable sequence to an async-iterable sequence, +switchMap | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function switchMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Projects each element of an async-iterable sequence to an async-iterable sequence, emitting values only from the most recently projected async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the projected inner sequences and the elements in the merged result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • selector: FlattenConcurrentSelector<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A transform function to apply to each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional thisArg: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Option this for binding to the selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator that creates an async-iterable sequence whose +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the projected inner sequences and the elements in the merged result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selector: FlattenConcurrentSelector<TSource, TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A transform function to apply to each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional thisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Option this for binding to the selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that creates an async-iterable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.take.html b/docs/functions/asynciterable_operators.take.html index 53200124..ecaebb0f 100644 --- a/docs/functions/asynciterable_operators.take.html +++ b/docs/functions/asynciterable_operators.take.html @@ -1,6 +1,142 @@ -take | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function take

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • take<TSource>(count): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns a specified number of contiguous elements from the start of an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • count: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of elements to return.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains the specified +take | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function take

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns a specified number of contiguous elements from the start of an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The number of elements to return.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the specified number of elements from the start of the input sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.takeLast.html b/docs/functions/asynciterable_operators.takeLast.html index 06a57d9f..65294c0a 100644 --- a/docs/functions/asynciterable_operators.takeLast.html +++ b/docs/functions/asynciterable_operators.takeLast.html @@ -1,6 +1,142 @@ -takeLast | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function takeLast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • takeLast<TSource>(count): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns a specified number of contiguous elements from the end of an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • count: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Number of elements to take from the end of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence containing the specified +takeLast | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function takeLast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns a specified number of contiguous elements from the end of an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Number of elements to take from the end of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing the specified number of elements from the end of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.takeUntil.html b/docs/functions/asynciterable_operators.takeUntil.html index dc4f4b63..814087cc 100644 --- a/docs/functions/asynciterable_operators.takeUntil.html +++ b/docs/functions/asynciterable_operators.takeUntil.html @@ -1,8 +1,155 @@ -takeUntil | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function takeUntil

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • takeUntil<TSource>(other): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the elements from the source async-iterable sequence until the other function +takeUntil | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function takeUntil

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns the elements from the source async-iterable sequence until the other function that returns a promise produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • other: ((signal?) => Promise<any>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function that terminates the propagation of +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          other: ((signal?) => Promise<any>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function that terminates the propagation of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (signal?): Promise<any>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns Promise<any>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An async-iterable sequence containing the elements of the +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (signal?): Promise<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns Promise<any>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence containing the elements of the source sequence up to the point the other function which returns a promise interrupted further propagation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.takeWhile.html b/docs/functions/asynciterable_operators.takeWhile.html index 502a6c40..5eef8585 100644 --- a/docs/functions/asynciterable_operators.takeWhile.html +++ b/docs/functions/asynciterable_operators.takeWhile.html @@ -1,12 +1,203 @@ -takeWhile | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function takeWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • takeWhile<T, S>(predicate): OperatorAsyncFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns elements from an async-iterable sequence as long as a specified condition is true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The result of the predicate that is truthy/falsy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • predicate: ((value, index, signal?) => value is S)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index, signal?): value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains the elements from the input sequence that occur +takeWhile | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function takeWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns elements from an async-iterable sequence as long as a specified condition is true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The result of the predicate that is truthy/falsy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        predicate: ((value, index, signal?) => value is S)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, index, signal?): value is S
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • takeWhile<T>(predicate): OperatorAsyncFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Returns elements from an async-iterable sequence as long as a specified condition is true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • predicate: ((value, index, signal?) => boolean | Promise<boolean>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, index, signal?): boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements from the input sequence that occur + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns elements from an async-iterable sequence as long as a specified condition is true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        predicate: ((value, index, signal?) => boolean | Promise<boolean>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, index, signal?): boolean | Promise<boolean>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.tap.html b/docs/functions/asynciterable_operators.tap.html index 0653f06c..86de10e6 100644 --- a/docs/functions/asynciterable_operators.tap.html +++ b/docs/functions/asynciterable_operators.tap.html @@ -1,15 +1,180 @@ -tap | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function tap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • tap<TSource>(observer): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Invokes an action for each element in the async-iterable sequence, and propagates all observer +tap | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function tap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Invokes an action for each element in the async-iterable sequence, and propagates all observer messages through the result sequence. This method can be used for debugging, logging, etc. by intercepting the message stream to run arbitrary actions for messages on the pipeline.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • observer: PartialAsyncObserver<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Observer whose methods to invoke as part of the source sequence's observation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence with the side-effecting behavior applied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tap<TSource>(next?, error?, complete?): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Invokes an action for each element in the async-iterable sequence, and propagates all observer +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        observer: PartialAsyncObserver<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Observer whose methods to invoke as part of the source sequence's observation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence with the side-effecting behavior applied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Invokes an action for each element in the async-iterable sequence, and propagates all observer messages through the result sequence. This method can be used for debugging, logging, etc. by intercepting the message stream to run arbitrary actions for messages on the pipeline.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional next: null | ((value) => any)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function to invoke for each element in the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional error: null | ((err) => any)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function to invoke upon exceptional termination of the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional complete: null | (() => any)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function to invoke upon graceful termination of the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence with the side-effecting behavior applied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional next: null | ((value) => any)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function to invoke for each element in the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional error: null | ((err) => any)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function to invoke upon exceptional termination of the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional complete: null | (() => any)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function to invoke upon graceful termination of the async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The source sequence with the side-effecting behavior applied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.thenBy.html b/docs/functions/asynciterable_operators.thenBy.html index 1a814662..33591f24 100644 --- a/docs/functions/asynciterable_operators.thenBy.html +++ b/docs/functions/asynciterable_operators.thenBy.html @@ -1,8 +1,176 @@ -thenBy | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function thenBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • thenBy<TKey, TSource>(keySelector, comparer?): UnaryFunction<AsyncIterable<TSource>, OrderedAsyncIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Performs a subsequent ordering of the elements in a sequence in ascending order according to a key using a specified comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the key returned by keySelector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • keySelector: ((item) => TKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to extract a key from an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (item): TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • item: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional comparer: ((fst, snd) => number) = defaultSorter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A comparer to compare keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (fst, snd): number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • snd: TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<AsyncIterable<TSource>, OrderedAsyncIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An ordered async-iterable whose elements are +thenBy | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function thenBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Performs a subsequent ordering of the elements in a sequence in ascending order according to a key using a specified comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the key returned by keySelector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keySelector: ((item) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to extract a key from an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (item): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              item: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional comparer: ((fst, snd) => number) = defaultSorter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A comparer to compare keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (fst, snd): number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              snd: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns UnaryFunction<AsyncIterable<TSource>, OrderedAsyncIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An ordered async-iterable whose elements are sorted according to a key and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.thenByDescending.html b/docs/functions/asynciterable_operators.thenByDescending.html index 62c33458..86e0d91c 100644 --- a/docs/functions/asynciterable_operators.thenByDescending.html +++ b/docs/functions/asynciterable_operators.thenByDescending.html @@ -1,8 +1,176 @@ -thenByDescending | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function thenByDescending

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • thenByDescending<TKey, TSource>(keySelector, comparer?): UnaryFunction<AsyncIterable<TSource>, OrderedAsyncIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Performs a subsequent ordering of the elements in a sequence in descending order according to a key using a specified comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the key returned by keySelector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • keySelector: ((item) => TKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to extract a key from an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (item): TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • item: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional comparer: ((fst, snd) => number) = defaultSorter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A comparer to compare keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (fst, snd): number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • snd: TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<AsyncIterable<TSource>, OrderedAsyncIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An ordered async-iterable whose elements are +thenByDescending | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function thenByDescending

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Performs a subsequent ordering of the elements in a sequence in descending order according to a key using a specified comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the key returned by keySelector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keySelector: ((item) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to extract a key from an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (item): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              item: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional comparer: ((fst, snd) => number) = defaultSorter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A comparer to compare keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (fst, snd): number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              snd: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns UnaryFunction<AsyncIterable<TSource>, OrderedAsyncIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An ordered async-iterable whose elements are sorted in descending order according to a key and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.throttle.html b/docs/functions/asynciterable_operators.throttle.html index 1d808134..078dffb2 100644 --- a/docs/functions/asynciterable_operators.throttle.html +++ b/docs/functions/asynciterable_operators.throttle.html @@ -1,5 +1,141 @@ -throttle | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function throttle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • throttle<TSource>(time): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Throttles the source async-iterable sequence so that it doesn't emit more than one value during the given timeframe.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • time: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The time in milliseconds to throttle the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The source sequence throttled by the given timeframe.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +throttle | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function throttle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Throttles the source async-iterable sequence so that it doesn't emit more than one value during the given timeframe.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      time: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The time in milliseconds to throttle the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The source sequence throttled by the given timeframe.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.timeInterval.html b/docs/functions/asynciterable_operators.timeInterval.html index ff154840..c0b2b4b4 100644 --- a/docs/functions/asynciterable_operators.timeInterval.html +++ b/docs/functions/asynciterable_operators.timeInterval.html @@ -1,5 +1,134 @@ -timeInterval | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function timeInterval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • timeInterval<TSource>(): OperatorAsyncFunction<TSource, TimeInterval<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Records the time interval between consecutive elements in an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, TimeInterval<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with time +timeInterval | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function timeInterval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Records the time interval between consecutive elements in an async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<TSource, TimeInterval<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence with time interval information on elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.timeout.html b/docs/functions/asynciterable_operators.timeout.html index 770a6e77..0c85d791 100644 --- a/docs/functions/asynciterable_operators.timeout.html +++ b/docs/functions/asynciterable_operators.timeout.html @@ -1,6 +1,142 @@ -timeout | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • timeout<TSource>(dueTime): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Applies a timeout policy for each element in the async-iterable sequence. +timeout | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Applies a timeout policy for each element in the async-iterable sequence. If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutError is thrown.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • dueTime: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Maximum duration in milliseconds between values before a timeout occurs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence with a TimeoutError in case of a timeout.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dueTime: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Maximum duration in milliseconds between values before a timeout occurs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The source sequence with a TimeoutError in case of a timeout.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.timestamp.html b/docs/functions/asynciterable_operators.timestamp.html index d061c76e..e1a4ea4d 100644 --- a/docs/functions/asynciterable_operators.timestamp.html +++ b/docs/functions/asynciterable_operators.timestamp.html @@ -1,4 +1,133 @@ -timestamp | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function timestamp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • timestamp<TSource>(): OperatorAsyncFunction<TSource, Timestamp<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Timestamps each element in an async-iterable sequence using the local system clock.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, Timestamp<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with timestamp information on elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +timestamp | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function timestamp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Timestamps each element in an async-iterable sequence using the local system clock.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<TSource, Timestamp<TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence with timestamp information on elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.toDOMStream.html b/docs/functions/asynciterable_operators.toDOMStream.html index 3295fe2b..e0f8efc3 100644 --- a/docs/functions/asynciterable_operators.toDOMStream.html +++ b/docs/functions/asynciterable_operators.toDOMStream.html @@ -1 +1,161 @@ -toDOMStream | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStream<T>(strategy?): UnaryFunction<AsyncIterable<T>, ReadableStream<T>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional strategy: QueuingStrategy<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<AsyncIterable<T>, ReadableStream<T>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStream<T>(options): UnaryFunction<AsyncIterable<T>, ReadableStream<Uint8Array>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: ReadableBYOBStreamOptions<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<AsyncIterable<T>, ReadableStream<Uint8Array>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStream<T>(options): UnaryFunction<AsyncIterable<T>, ReadableStream<Uint8Array>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: ReadableByteStreamOptions<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<AsyncIterable<T>, ReadableStream<Uint8Array>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +toDOMStream | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional strategy: QueuingStrategy<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<AsyncIterable<T>, ReadableStream<T>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ReadableBYOBStreamOptions<Uint8Array>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<AsyncIterable<T>, ReadableStream<Uint8Array>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ReadableByteStreamOptions<Uint8Array>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<AsyncIterable<T>, ReadableStream<Uint8Array>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.union.html b/docs/functions/asynciterable_operators.union.html index 5c8612f8..e6f27215 100644 --- a/docs/functions/asynciterable_operators.union.html +++ b/docs/functions/asynciterable_operators.union.html @@ -1,7 +1,160 @@ -union | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function union

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • union<TSource>(right, comparer?): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Produces the set union of two sequences by using the given equality comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of the input sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • right: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence whose distinct elements form the second set for the union.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional comparer: ((x, y) => boolean | Promise<boolean>) = comparerAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The equality comparer to compare values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (x, y): boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • x: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • y: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence that contains the elements from both input sequences, +union | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function union

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Produces the set union of two sequences by using the given equality comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements of the input sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        right: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An async-iterable sequence whose distinct elements form the second set for the union.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional comparer: ((x, y) => boolean | Promise<boolean>) = comparerAsync
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The equality comparer to compare values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (x, y): boolean | Promise<boolean>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              x: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              y: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean | Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence that contains the elements from both input sequences, excluding duplicates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.withAbort.html b/docs/functions/asynciterable_operators.withAbort.html index 496ff45c..5dd59c15 100644 --- a/docs/functions/asynciterable_operators.withAbort.html +++ b/docs/functions/asynciterable_operators.withAbort.html @@ -1,5 +1,141 @@ -withAbort | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function withAbort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • withAbort<TSource>(signal): MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Wraps the existing async-iterable sequence with an abort signal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The abort signal used for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable that can be cancelled by the abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +withAbort | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function withAbort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Wraps the existing async-iterable sequence with an abort signal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The abort signal used for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorAsyncFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable that can be cancelled by the abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.withLatestFrom.html b/docs/functions/asynciterable_operators.withLatestFrom.html index 67711f3d..cde66d9c 100644 --- a/docs/functions/asynciterable_operators.withLatestFrom.html +++ b/docs/functions/asynciterable_operators.withLatestFrom.html @@ -1,62 +1,403 @@ -withLatestFrom | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function withLatestFrom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • withLatestFrom<T, T2>(source2): OperatorAsyncFunction<T, [T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining each element +withLatestFrom | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function withLatestFrom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence by combining each element from the first source with the latest element from the other sources, if any.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence containing the result of combining +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, [T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence containing the result of combining each element of the first source with the latest element from the second source, if any as an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • withLatestFrom<T, T2, T3>(source2, source3): OperatorAsyncFunction<T, [T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining each element + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple async-iterable sequences into one async-iterable sequence by combining each element from the first source with the latest element from the other sources, if any.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, [T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable sequence containing the result of combining +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, [T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence containing the result of combining each element of the first source with the latest element from the second source, if any as an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • withLatestFrom<T, T2, T3, T4>(source2, source3, source4): OperatorAsyncFunction<T, [T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Merges multiple async-iterable sequences into one async-iterable sequence by combining each element + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merges multiple async-iterable sequences into one async-iterable sequence by combining each element from the first source with the latest element from the other sources, if any.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, [T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence containing the result of combining +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, [T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence containing the result of combining each element of the first source with the latest element from the second source, if any as an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • withLatestFrom<T, T2, T3, T4, T5>(source2, source3, source4, source5): OperatorAsyncFunction<T, [T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Merges multiple async-iterable sequences into one async-iterable sequence by combining each element + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merges multiple async-iterable sequences into one async-iterable sequence by combining each element from the first source with the latest element from the other sources, if any.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence containing the result of combining + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence containing the result of combining each element of the first source with the latest element from the second source, if any as an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • withLatestFrom<T, T2, T3, T4, T5, T6>(source2, source3, source4, source5, source6): OperatorAsyncFunction<T, [T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Merges multiple async-iterable sequences into one async-iterable sequence by combining each element + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merges multiple async-iterable sequences into one async-iterable sequence by combining each element from the first source with the latest element from the other sources, if any.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • source6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence containing the result of combining + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence containing the result of combining each element of the first source with the latest element from the second source, if any as an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • withLatestFrom<T>(...sources): OperatorAsyncFunction<T, T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Merges multiple async-iterable sequences into one async-iterable sequence by combining each element + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merges multiple async-iterable sequences into one async-iterable sequence by combining each element from the first source with the latest element from the other sources, if any.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Rest ...sources: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence containing the result of combining + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Rest ...sources: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorAsyncFunction<T, T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An async-iterable sequence containing the result of combining each element of the first source with the latest element from the second source, if any as an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.wrapWithAbort.html b/docs/functions/asynciterable_operators.wrapWithAbort.html index 59bf08e5..4936e1b5 100644 --- a/docs/functions/asynciterable_operators.wrapWithAbort.html +++ b/docs/functions/asynciterable_operators.wrapWithAbort.html @@ -1,6 +1,146 @@ -wrapWithAbort | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function wrapWithAbort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • wrapWithAbort<TSource>(source, signal?): AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Wraps an existing async-iterable with a new async-iterable which support cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence to wrap with the abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional signal: AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The abort signal used for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The source sequence wrapped with an abort signal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +wrapWithAbort | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function wrapWithAbort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Wraps an existing async-iterable with a new async-iterable which support cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: AsyncIterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence to wrap with the abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional signal: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The abort signal used for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The source sequence wrapped with an abort signal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/asynciterable_operators.zipWith.html b/docs/functions/asynciterable_operators.zipWith.html index 65f49d69..dc3200a4 100644 --- a/docs/functions/asynciterable_operators.zipWith.html +++ b/docs/functions/asynciterable_operators.zipWith.html @@ -1,52 +1,393 @@ -zipWith | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function zipWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zipWith<T, T2>(source2): OperatorAsyncFunction<T, [T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, [T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zipWith<T, T2, T3>(source2, source3): OperatorAsyncFunction<T, [T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, [T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zipWith<T, T2, T3, T4>(source2, source3, source4): OperatorAsyncFunction<T, [T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, [T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zipWith<T, T2, T3, T4, T5>(source2, source3, source4, source5): OperatorAsyncFunction<T, [T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source +zipWith | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function zipWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • zipWith<T, T2, T3, T4, T5, T6>(source2, source3, source4, source5, source6): OperatorAsyncFunction<T, [T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: AsyncIterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source3: AsyncIterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source4: AsyncIterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source5: AsyncIterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source6: AsyncIterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async iterable with an array of each element from the source + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: AsyncIterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: AsyncIterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: AsyncIterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source5: AsyncIterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source6: AsyncIterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • zipWith<T>(...sources): OperatorAsyncFunction<T, T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Rest ...sources: AsyncIterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorAsyncFunction<T, T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple async-iterable sequences into one async-iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: AsyncIterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorAsyncFunction<T, T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/dom.fromDOMStream.html b/docs/functions/dom.fromDOMStream.html new file mode 100644 index 00000000..81598ada --- /dev/null +++ b/docs/functions/dom.fromDOMStream.html @@ -0,0 +1,109 @@ +fromDOMStream | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates an async-iterable from an existing DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stream: ReadableStream<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The DOM Readable stream to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable containing the elements from the ReadableStream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates an async-iterable from an existing DOM stream and options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource extends ArrayBufferView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stream: ReadableStream<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The readable stream to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mode: "byob";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options to set the mode for the DOM stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mode: "byob"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable created from the incoming async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.as.html b/docs/functions/iterable.as.html index 1bc958eb..dd7089e1 100644 --- a/docs/functions/iterable.as.html +++ b/docs/functions/iterable.as.html @@ -1,16 +1,182 @@ -as | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function as

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • as(source): Iterable<string>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts an existing string into an iterable of characters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The string to convert to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<string>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An terable stream of characters from the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • as<T>(source): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts the iterable like input into an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The tyep of elements in the source iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The iterable to convert to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable stream of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • as<T>(source): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts an array-like object to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source array-like sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: ArrayLike<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The array-like sequence to convert to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The iterable containing the elements from the array-like sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • as<T>(source): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts the object into a singleton in an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of element to turn into an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The item to turn into an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence from the source object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +as | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function as

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an existing string into an iterable of characters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The string to convert to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<string>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An terable stream of characters from the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts the iterable like input into an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The tyep of elements in the source iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The iterable to convert to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable stream of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an array-like object to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source array-like sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: ArrayLike<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The array-like sequence to convert to an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The iterable containing the elements from the array-like sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts the object into a singleton in an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of element to turn into an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The item to turn into an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence from the source object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.average.html b/docs/functions/iterable.average.html index 703ec42d..1652b8db 100644 --- a/docs/functions/iterable.average.html +++ b/docs/functions/iterable.average.html @@ -1,10 +1,142 @@ -average | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function average

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • average(source, options?): number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Computes the average of the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source iterable sequence to compute the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: MathOptions<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for calculating the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The computed average for the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • average<T>(source, options?): number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Computes the average of the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source iterable sequence to compute the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: MathOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for calculating the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The computed average for the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +average | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function average

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Computes the average of the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source iterable sequence to compute the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: MathOptions<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for calculating the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The computed average for the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Computes the average of the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source iterable sequence to compute the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: MathOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for calculating the average.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The computed average for the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.concat.html b/docs/functions/iterable.concat.html index e6845c06..d5c29388 100644 --- a/docs/functions/iterable.concat.html +++ b/docs/functions/iterable.concat.html @@ -1,60 +1,393 @@ -concat | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function concat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concat<T>(v1): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates all iterable sequences in the given sequences, as long as the previous iterable +concat | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function concat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates all iterable sequences in the given sequences, as long as the previous iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v1: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • concat<T, T2>(v1, v2): Iterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Concatenates the second iterable sequence to the first iterable sequence upon successful termination of the first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v1: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Iterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements of the first sequence, +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v1: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Concatenates the second iterable sequence to the first iterable sequence upon successful termination of the first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v1: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements of the first sequence, followed by those of the second the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concat<T, T2, T3>(v1, v2, v3): Iterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates all iterable sequences in the given sequences, as long as the previous iterable + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Concatenates all iterable sequences in the given sequences, as long as the previous iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v1: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concat<T, T2, T3, T4>(v1, v2, v3, v4): Iterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates all iterable sequences in the given sequences, as long as the previous iterable +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v1: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Concatenates all iterable sequences in the given sequences, as long as the previous iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v1: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concat<T, T2, T3, T4, T5>(v1, v2, v3, v4, v5): Iterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates all iterable sequences in the given sequences, as long as the previous iterable +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v1: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Concatenates all iterable sequences in the given sequences, as long as the previous iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v1: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v5: Iterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concat<T, T2, T3, T4, T5, T6>(v1, v2, v3, v4, v5, v6): Iterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates all iterable sequences in the given sequences, as long as the previous iterable +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v1: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v5: Iterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Concatenates all iterable sequences in the given sequences, as long as the previous iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v1: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v5: Iterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fifth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v6: Iterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sixth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v1: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    First iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v5: Iterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v6: Iterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sixth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns Iterable<T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.count.html b/docs/functions/iterable.count.html index 13edd881..225f0c10 100644 --- a/docs/functions/iterable.count.html +++ b/docs/functions/iterable.count.html @@ -1,8 +1,122 @@ -count | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function count

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • count<T>(source, options?): number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns a promise that represents how many elements in the specified iterable sequence satisfy a condition +count | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function count

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns a promise that represents how many elements in the specified iterable sequence satisfy a condition otherwise, the number of items in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source collection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An iterable sequence that contains elements to be counted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional options: OptionalFindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The options for a predicate for filtering and thisArg for binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of matching elements for the given condition if provided, otherwise +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source collection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains elements to be counted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: OptionalFindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for a predicate for filtering and thisArg for binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The number of matching elements for the given condition if provided, otherwise the number of elements in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.create.html b/docs/functions/iterable.create.html index 04033153..31e104e5 100644 --- a/docs/functions/iterable.create.html +++ b/docs/functions/iterable.create.html @@ -1,4 +1,118 @@ -create | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • create<T>(getIterator): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates a new iterable using the specified function implementing the members of AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements returned by the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • getIterator: (() => Iterator<T, any, undefined>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (): Iterator<T, any, undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns Iterator<T, any, undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A new iterable instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +create | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates a new iterable using the specified function implementing the members of AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements returned by the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getIterator: (() => Iterator<T, any, undefined>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (): Iterator<T, any, undefined>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns Iterator<T, any, undefined>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A new iterable instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.defer.html b/docs/functions/iterable.defer.html index 1ec1ea3d..61a7d61b 100644 --- a/docs/functions/iterable.defer.html +++ b/docs/functions/iterable.defer.html @@ -1,5 +1,121 @@ -defer | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function defer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • defer<TSource>(factory): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns an iterable sequence that invokes the specified factory function whenever a call to [Symbol.iterator] has been made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sequence returned by the factory function, and in the resulting sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • factory: (() => Iterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      iterable factory function to invoke for each call to [Symbol.iterator].

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence whose observers trigger an invocation of the given iterable factory function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +defer | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function defer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns an iterable sequence that invokes the specified factory function whenever a call to [Symbol.iterator] has been made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the sequence returned by the factory function, and in the resulting sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      factory: (() => Iterable<TSource>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      iterable factory function to invoke for each call to [Symbol.iterator].

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (): Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence whose observers trigger an invocation of the given iterable factory function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.elementAt.html b/docs/functions/iterable.elementAt.html index 56b7a2ee..8249d914 100644 --- a/docs/functions/iterable.elementAt.html +++ b/docs/functions/iterable.elementAt.html @@ -1,7 +1,121 @@ -elementAt | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function elementAt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • elementAt<T>(source, index): T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the element at a specified index in a sequence or undefined if the index is out of range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      iterable sequence to return the element from.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The zero-based index of the element to retrieve.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that produces the element at the specified +elementAt | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function elementAt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns the element at a specified index in a sequence or undefined if the index is out of range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        iterable sequence to return the element from.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The zero-based index of the element to retrieve.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that produces the element at the specified position in the source sequence, or undefined if the index is outside the bounds of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.empty.html b/docs/functions/iterable.empty.html index d7d904be..50af7a33 100644 --- a/docs/functions/iterable.empty.html +++ b/docs/functions/iterable.empty.html @@ -1,3 +1,99 @@ -empty | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +empty | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.every.html b/docs/functions/iterable.every.html index 9d48247c..39c0dc6d 100644 --- a/docs/functions/iterable.every.html +++ b/docs/functions/iterable.every.html @@ -1,6 +1,120 @@ -every | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function every

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • every<T>(source, options): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Determines whether all elements of an iterable sequence satisfy a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: FindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for a predicate for filtering, thisArg for binding and AbortSignal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A boolean determining whether all elements in the source sequence pass the test in the specified predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +every | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function every

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines whether all elements of an iterable sequence satisfy a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: FindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for a predicate for filtering, thisArg for binding and AbortSignal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A boolean determining whether all elements in the source sequence pass the test in the specified predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.find.html b/docs/functions/iterable.find.html index e59ca060..5c508cde 100644 --- a/docs/functions/iterable.find.html +++ b/docs/functions/iterable.find.html @@ -1,6 +1,120 @@ -find | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function find

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • find<T>(source, options): T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the value of the first element in the provided iterable that satisfies the provided testing function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: FindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for a predicate for filtering, thisArg for binding and AbortSignal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The first element that matches the predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +find | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function find

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the value of the first element in the provided iterable that satisfies the provided testing function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: FindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for a predicate for filtering, thisArg for binding and AbortSignal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The first element that matches the predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.findIndex.html b/docs/functions/iterable.findIndex.html index 200103ec..ec412566 100644 --- a/docs/functions/iterable.findIndex.html +++ b/docs/functions/iterable.findIndex.html @@ -1,7 +1,121 @@ -findIndex | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function findIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • findIndex<T>(source, options): number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the index of the first element in the array that satisfies the provided testing function. +findIndex | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function findIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns the index of the first element in the array that satisfies the provided testing function. Otherwise, it returns -1, indicating that no element passed the test.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • options: FindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The options for a predicate for filtering, thisArg for binding and AbortSignal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The index of the first element in the array that passes the test. Otherwise, -1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: FindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for a predicate for filtering, thisArg for binding and AbortSignal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The index of the first element in the array that passes the test. Otherwise, -1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.first.html b/docs/functions/iterable.first.html index ea85e3f5..81add01d 100644 --- a/docs/functions/iterable.first.html +++ b/docs/functions/iterable.first.html @@ -1,5 +1,117 @@ -first | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function first

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • first<T>(source, options?): T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the first element of an iterable sequence that matches the predicate if provided, or undefined if no such element exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source async-enumerable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: OptionalFindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The first element in the iterable sequence, or undefined if no such element exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +first | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function first

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the first element of an iterable sequence that matches the predicate if provided, or undefined if no such element exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source async-enumerable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: OptionalFindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The first element in the iterable sequence, or undefined if no such element exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.from.html b/docs/functions/iterable.from.html index cbcb237e..272bcf03 100644 --- a/docs/functions/iterable.from.html +++ b/docs/functions/iterable.from.html @@ -1 +1,126 @@ -from | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • from<TSource, TResult>(source, selector?, thisArg?): Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<TSource> | Iterator<TSource, any, undefined> | ArrayLike<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • selector: ((value, index) => TResult) = identity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index): TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional thisArg: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nocollapse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +from | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TResult = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<TSource> | Iterator<TSource, any, undefined> | ArrayLike<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selector: ((value, index) => TResult) = identity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index): TResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional thisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nocollapse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.generate.html b/docs/functions/iterable.generate.html index 67eddc3e..18577b70 100644 --- a/docs/functions/iterable.generate.html +++ b/docs/functions/iterable.generate.html @@ -1,10 +1,169 @@ -generate | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function generate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • generate<TState, TResult>(initialState, condition, iterate, resultSelector): Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Generates an iterable sequence by running a state-driven loop producing the sequence's elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the state used in the generator loop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the produced sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • initialState: TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The initial state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • condition: ((value) => boolean)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Condition to terminate generation (upon returning false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • iterate: ((value) => TState)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Iteration step function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value): TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • resultSelector: ((value) => TResult)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Selector function for results produced in +generate | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function generate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Generates an iterable sequence by running a state-driven loop producing the sequence's elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the state used in the generator loop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the produced sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          initialState: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The initial state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          condition: ((value) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Condition to terminate generation (upon returning false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          iterate: ((value) => TState)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Iteration step function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resultSelector: ((value) => TResult)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Selector function for results produced in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The generated iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value): TResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: TState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The generated iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.includes.html b/docs/functions/iterable.includes.html index 37e4e0bd..92b51f5f 100644 --- a/docs/functions/iterable.includes.html +++ b/docs/functions/iterable.includes.html @@ -1,6 +1,122 @@ -includes | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function includes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • includes<T>(source, searchElement, fromIndex?): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Determines whether an itreable includes a certain value among its entries, returning true or false as appropriate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence to search for the item.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • searchElement: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional fromIndex: number = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The position in this iterable at which to begin searching for valueToFind.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns true if the value valueToFind is found within the iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +includes | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function includes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines whether an itreable includes a certain value among its entries, returning true or false as appropriate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence to search for the item.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      searchElement: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional fromIndex: number = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The position in this iterable at which to begin searching for valueToFind.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns true if the value valueToFind is found within the iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.isEmpty.html b/docs/functions/iterable.isEmpty.html index 91ec47b3..0b80de03 100644 --- a/docs/functions/iterable.isEmpty.html +++ b/docs/functions/iterable.isEmpty.html @@ -1,5 +1,115 @@ -isEmpty | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • isEmpty<T>(source): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Determines whether the given async-iterable is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source async-iterable to determine whether it is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns true if the sequence is empty, otherwise false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +isEmpty | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines whether the given async-iterable is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source async-iterable to determine whether it is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns true if the sequence is empty, otherwise false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.last.html b/docs/functions/iterable.last.html index 18959ba4..e453ce5a 100644 --- a/docs/functions/iterable.last.html +++ b/docs/functions/iterable.last.html @@ -1,8 +1,122 @@ -last | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function last

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • last<T>(source, options?): T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the last element of an iterable sequence that satisfies the condition in the predicate if given +last | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function last

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns the last element of an iterable sequence that satisfies the condition in the predicate if given otherwise the last item in the sequence, or a default value if no such element exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The source iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional options: OptionalFindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The options which include an optional predicate for filtering, +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The source iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional options: OptionalFindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The options which include an optional predicate for filtering, thirArg for binding, and abort signal for cancellation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The last value that matches the optional predicate or last item, otherwise undefined.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The last value that matches the optional predicate or last item, otherwise undefined.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.max.html b/docs/functions/iterable.max.html index 3d210fea..a4b887ad 100644 --- a/docs/functions/iterable.max.html +++ b/docs/functions/iterable.max.html @@ -1,6 +1,122 @@ -max | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • max<TSource, TResult>(source, options?): TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the maximum element with the optional selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence to determine the maximum element of.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: ExtremaOptions<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which include an optional comparer and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The maximum element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +max | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the maximum element with the optional selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TResult = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence to determine the maximum element of.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: ExtremaOptions<TSource, TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which include an optional comparer and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The maximum element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.maxBy.html b/docs/functions/iterable.maxBy.html index 6be64768..392130d8 100644 --- a/docs/functions/iterable.maxBy.html +++ b/docs/functions/iterable.maxBy.html @@ -1,7 +1,125 @@ -maxBy | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function maxBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • maxBy<TSource, TKey>(source, options?): TSource[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the elements in an iterable sequence with the maximum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source to get the maximum by.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: ExtremaOptions<TSource, TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which include an optional comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns TSource[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A list of zero or more elements that have a maximum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +maxBy | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function maxBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the elements in an iterable sequence with the maximum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source to get the maximum by.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: ExtremaOptions<TSource, TKey>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which include an optional comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns TSource[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A list of zero or more elements that have a maximum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.min.html b/docs/functions/iterable.min.html index 9b518f3c..2f8d2835 100644 --- a/docs/functions/iterable.min.html +++ b/docs/functions/iterable.min.html @@ -1,8 +1,124 @@ -min | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • min<TSource, TResult>(source, options?): TResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +min | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns the minimum element with the optional selector.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • TResult = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • source: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An iterable sequence to determine the minimum element of.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optional options: ExtremaOptions<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The options which include an optional comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The minimum element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TResult = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence to determine the minimum element of.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: ExtremaOptions<TSource, TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which include an optional comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The minimum element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.minBy.html b/docs/functions/iterable.minBy.html index 3686f889..9ba0bff1 100644 --- a/docs/functions/iterable.minBy.html +++ b/docs/functions/iterable.minBy.html @@ -1,7 +1,125 @@ -minBy | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function minBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • minBy<TSource, TKey>(source, options?): TSource[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the elements in an terable sequence with the minimum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence to get the minimum elements for.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: ExtremaOptions<TSource, TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which include an optional comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns TSource[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A list of zero or more elements that have a minimum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +minBy | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function minBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the elements in an terable sequence with the minimum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-iterable sequence to get the minimum elements for.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: ExtremaOptions<TSource, TKey>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which include an optional comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns TSource[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A list of zero or more elements that have a minimum key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.onErrorResumeNext.html b/docs/functions/iterable.onErrorResumeNext.html index 871c368f..d400f25a 100644 --- a/docs/functions/iterable.onErrorResumeNext.html +++ b/docs/functions/iterable.onErrorResumeNext.html @@ -1,4 +1,112 @@ -onErrorResumeNext | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function onErrorResumeNext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • onErrorResumeNext<T>(...source): Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates all of the specified iterable sequences, even if the previous iterable sequence terminated exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...source: Iterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that concatenates the source sequences, even if a sequence terminates exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +onErrorResumeNext | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function onErrorResumeNext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Concatenates all of the specified iterable sequences, even if the previous iterable sequence terminated exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...source: Iterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that concatenates the source sequences, even if a sequence terminates exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.range.html b/docs/functions/iterable.range.html index 09da7249..3b2112c8 100644 --- a/docs/functions/iterable.range.html +++ b/docs/functions/iterable.range.html @@ -1,5 +1,112 @@ -range | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • range(start, count): Iterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Generates an iterable sequence of integral numbers within a specified range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • start: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value of the first integer in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • count: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of sequential integers to generate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains a range of sequential integral numbers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +range | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Generates an iterable sequence of integral numbers within a specified range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      start: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value of the first integer in the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of sequential integers to generate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains a range of sequential integral numbers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.reduce.html b/docs/functions/iterable.reduce.html index 66b88516..1ee85d5e 100644 --- a/docs/functions/iterable.reduce.html +++ b/docs/functions/iterable.reduce.html @@ -1,9 +1,163 @@ -reduce | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function reduce

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • reduce<T, R>(source, options): R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Applies an accumulator function over an iterable sequence, returning the result of the aggregation as a +reduce | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function reduce

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Applies an accumulator function over an iterable sequence, returning the result of the aggregation as a single element in the result sequence. The seed value, if specified, is used as the initial accumulator value. For aggregation behavior with incremental intermediate results, scan.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An iterable sequence to aggregate over.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • options: ReduceOptions<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The options which contains a callback and optional seed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The final accumulator value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • reduce<T, R>(source, accumulator, seed?): R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (accumulator, current, index): R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • accumulator: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • current: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional seed: R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence to aggregate over.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ReduceOptions<T, R>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which contains a callback and optional seed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The final accumulator value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (accumulator, current, index): R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            accumulator: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            current: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional seed: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.reduceRight.html b/docs/functions/iterable.reduceRight.html index 5df4570f..ec8eb811 100644 --- a/docs/functions/iterable.reduceRight.html +++ b/docs/functions/iterable.reduceRight.html @@ -1,9 +1,163 @@ -reduceRight | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function reduceRight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • reduceRight<T, R>(source, options): R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Applies an accumulator function over an iterable sequence from the right, returning the result of the aggregation as a +reduceRight | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function reduceRight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Applies an accumulator function over an iterable sequence from the right, returning the result of the aggregation as a single element in the result sequence. The seed value, if specified, is used as the initial accumulator value. For aggregation behavior with incremental intermediate results, scan.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An iterable sequence to aggregate over.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • options: ReduceOptions<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The options which contains a callback and optional seed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The final accumulator value calculated from the right.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • reduceRight<T, R>(source, accumulator, seed?): R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (accumulator, current, index): R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • accumulator: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • current: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional seed: R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence to aggregate over.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ReduceOptions<T, R>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which contains a callback and optional seed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The final accumulator value calculated from the right.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (accumulator, current, index): R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            accumulator: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            current: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional seed: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.repeatValue.html b/docs/functions/iterable.repeatValue.html index f5f557d9..99836e6c 100644 --- a/docs/functions/iterable.repeatValue.html +++ b/docs/functions/iterable.repeatValue.html @@ -1,6 +1,120 @@ -repeatValue | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function repeatValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repeatValue<TSource>(value, count?): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Repeats a given value for the specified number of times as an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of element to repeat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • value: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to repeat as an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional count: number = -1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of times to repeat the value, infinite if not specified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable with a single item that is repeated over the specified times.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +repeatValue | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function repeatValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Repeats a given value for the specified number of times as an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of element to repeat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to repeat as an iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional count: number = -1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of times to repeat the value, infinite if not specified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable with a single item that is repeated over the specified times.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.sequenceEqual.html b/docs/functions/iterable.sequenceEqual.html index 91ae49a4..df4f4cc5 100644 --- a/docs/functions/iterable.sequenceEqual.html +++ b/docs/functions/iterable.sequenceEqual.html @@ -1,8 +1,126 @@ -sequenceEqual | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function sequenceEqual

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • sequenceEqual<T>(source, other, options?): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Determines whether two sequences are equal by comparing the elements pairwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      First iterable sequence to compare.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • other: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second iterable sequence to compare.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: SequencEqualOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The sequence equal options which include an optional comparer and optional abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise which indicates whether both sequences are of equal length and their +sequenceEqual | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function sequenceEqual

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines whether two sequences are equal by comparing the elements pairwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        First iterable sequence to compare.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        other: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second iterable sequence to compare.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional options: SequencEqualOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The sequence equal options which include an optional comparer and optional abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A promise which indicates whether both sequences are of equal length and their corresponding elements are equal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.single.html b/docs/functions/iterable.single.html index 4b6b65a7..5734fc73 100644 --- a/docs/functions/iterable.single.html +++ b/docs/functions/iterable.single.html @@ -1,10 +1,124 @@ -single | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function single

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • single<T>(source, options?): T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the only element of an iterable sequence that matches the predicate if specified, +single | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function single

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns the only element of an iterable sequence that matches the predicate if specified, or undefined if no such element exists; this method reports an exception if there is more than one element in the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional options: OptionalFindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The optional options which includes a predicate for filtering, +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Source iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional options: OptionalFindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The optional options which includes a predicate for filtering, and thisArg for predicate binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The single element in the iterable sequence that satisfies +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The single element in the iterable sequence that satisfies the condition in the predicate, or undefined if no such element exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.some.html b/docs/functions/iterable.some.html index 908c7ecc..53b7bb3e 100644 --- a/docs/functions/iterable.some.html +++ b/docs/functions/iterable.some.html @@ -1,8 +1,122 @@ -some | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function some

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • some<T>(source, options): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Determines whether any element of an iterable sequence satisfies a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: FindOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options which includes a required predicate, an optional +some | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function some

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines whether any element of an iterable sequence satisfies a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An iterable sequence whose elements to apply the predicate to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options: FindOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The options which includes a required predicate, an optional thisArg for binding, and an abort signal for cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns a boolean determining whether any elements in the source sequence +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a boolean determining whether any elements in the source sequence pass the test in the specified predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.sum.html b/docs/functions/iterable.sum.html index 21d72b2b..a5088564 100644 --- a/docs/functions/iterable.sum.html +++ b/docs/functions/iterable.sum.html @@ -1,10 +1,142 @@ -sum | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function sum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • sum(source, options?): number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Computes the sum of a sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A sequence of values to calculate the sum.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: MathOptions<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options for providing a selector, thisArg and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing the sum of the sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • sum<T>(source, options?): number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Computes the sum of a sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of values in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A sequence of values to calculate the sum.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: MathOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options for providing a selector, thisArg and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing the sum of the sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +sum | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function sum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Computes the sum of a sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A sequence of values to calculate the sum.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: MathOptions<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options for providing a selector, thisArg and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing the sum of the sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Computes the sum of a sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of values in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A sequence of values to calculate the sum.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: MathOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options for providing a selector, thisArg and abort signal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise containing the sum of the sequence of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.toArray.html b/docs/functions/iterable.toArray.html index bf576110..c9cfd070 100644 --- a/docs/functions/iterable.toArray.html +++ b/docs/functions/iterable.toArray.html @@ -1,5 +1,115 @@ -toArray | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toArray<TSource>(source): TSource[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts an existing iterable to anarray of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence to convert to an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns TSource[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All the items from the source sequence as an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +toArray | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an existing iterable to anarray of values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence to convert to an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns TSource[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All the items from the source sequence as an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.toDOMStream.html b/docs/functions/iterable.toDOMStream.html index 51c2085b..16d0ca76 100644 --- a/docs/functions/iterable.toDOMStream.html +++ b/docs/functions/iterable.toDOMStream.html @@ -1 +1,141 @@ -toDOMStream | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStream<T>(source, strategy?): ReadableStream<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional strategy: QueuingStrategy<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStream<T>(source, options): ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: ReadableBYOBStreamOptions<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStream<T>(source, options): ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: ReadableByteStreamOptions<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +toDOMStream | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional strategy: QueuingStrategy<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ReadableBYOBStreamOptions<Uint8Array>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ReadableByteStreamOptions<Uint8Array>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.toDOMStreamProto.html b/docs/functions/iterable.toDOMStreamProto.html deleted file mode 100644 index 47b07291..00000000 --- a/docs/functions/iterable.toDOMStreamProto.html +++ /dev/null @@ -1 +0,0 @@ -toDOMStreamProto | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toDOMStreamProto

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStreamProto<T>(this, options): ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: ReadableBYOBStreamOptions<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStreamProto<T>(this, options): ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: ReadableByteStreamOptions<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ReadableStream<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.toMap.html b/docs/functions/iterable.toMap.html index 8f6467ef..e0c3cdeb 100644 --- a/docs/functions/iterable.toMap.html +++ b/docs/functions/iterable.toMap.html @@ -1,8 +1,130 @@ -toMap | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toMap<TSource, TKey, TElement>(source, options): Map<TKey, TElement | TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts an async-iterable to a map with a key selector and options for an element selector and cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source collection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of key used for the map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TElement = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of element to use for the map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source collection to turn into a map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: ToMapOptions<TSource, TKey, TElement>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for getting the key and element for the map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Map<TKey, TElement | TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A map containing the key and elements from the selector functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +toMap | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an async-iterable to a map with a key selector and options for an element selector and cancellation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source collection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of key used for the map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TElement = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of element to use for the map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source collection to turn into a map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ToMapOptions<TSource, TKey, TElement>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options for getting the key and element for the map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Map<TKey, TElement | TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A map containing the key and elements from the selector functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.toSet.html b/docs/functions/iterable.toSet.html index ae8becfb..98203166 100644 --- a/docs/functions/iterable.toSet.html +++ b/docs/functions/iterable.toSet.html @@ -1,5 +1,115 @@ -toSet | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toSet<TSource>(source): Set<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Converts the existing iterable into a promise which resolves a Set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The iterable to convert into a set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Set<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise which contains a Set with all the elements from the iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +toSet | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts the existing iterable into a promise which resolves a Set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The iterable to convert into a set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Set<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise which contains a Set with all the elements from the iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable.zip.html b/docs/functions/iterable.zip.html index 4acd55bf..7af11cc6 100644 --- a/docs/functions/iterable.zip.html +++ b/docs/functions/iterable.zip.html @@ -1,55 +1,390 @@ -zip | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function zip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2>(source, source2): Iterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3>(source, source2, source3): Iterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3, T4>(source, source2, source3, source4): Iterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3, T4, T5>(source, source2, source3, source4, source5): Iterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: Iterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T, T2, T3, T4, T5, T6>(source, source2, source3, source4, source5, source6): Iterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source: Iterable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: Iterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source6: Iterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zip<T>(...sources): Iterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...sources: Iterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +zip | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function zip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: Iterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: Iterable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The first async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source5: Iterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source6: Iterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<[T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: Iterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Iterable<T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.buffer.html b/docs/functions/iterable_operators.buffer.html index 6fec2b82..e9fe6083 100644 --- a/docs/functions/iterable_operators.buffer.html +++ b/docs/functions/iterable_operators.buffer.html @@ -1,8 +1,127 @@ -buffer | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • buffer<TSource>(count, skip?): OperatorFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Generates a sequence of buffers over the source sequence, with specified length and possible overlap.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • count: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Number of elements for allocated buffers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional skip: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Number of elements to skip between the start of consecutive buffers. If not specified, defaults +buffer | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Generates a sequence of buffers over the source sequence, with specified length and possible overlap.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Number of elements for allocated buffers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional skip: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Number of elements to skip between the start of consecutive buffers. If not specified, defaults to the count.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns OperatorFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sequence of buffers containing source sequence elements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Example: Creates a sequence of buffers with and without skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const source = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // Without skip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const result = buffer(source, 5);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const result = Ix.Iterable.from(source).buffer(5);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        for (const item of result) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          console.log(result);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // => [0, 1, 2, 3, 4]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // => [5, 6, 7, 8, 9]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // With skip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const result = buffer(source, 3, 4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const result = Ix.Iterable.from(source).buffer(3, 4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        for (const item of result) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          console.log(result);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // => [0, 1, 2]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // => [4, 5, 6]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // => [8, 9]
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sequence of buffers containing source sequence elements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Example

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Creates a sequence of buffers with and without skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const source = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // Without skip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const result = buffer(source, 5);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const result = Ix.Iterable.from(source).buffer(5);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      for (const item of result) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        console.log(result);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // => [0, 1, 2, 3, 4]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // => [5, 6, 7, 8, 9]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // With skip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const result = buffer(source, 3, 4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const result = Ix.Iterable.from(source).buffer(3, 4);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      for (const item of result) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        console.log(result);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // => [0, 1, 2]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // => [4, 5, 6]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // => [8, 9]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.catchError.html b/docs/functions/iterable_operators.catchError.html index 2c908d28..f137a963 100644 --- a/docs/functions/iterable_operators.catchError.html +++ b/docs/functions/iterable_operators.catchError.html @@ -1,8 +1,138 @@ -catchError | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function catchError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • catchError<TSource, TResult>(handler): OperatorFunction<TSource, TSource | TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Continues an async-iterable sequence that is terminated by an exception with the +catchError | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function catchError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Continues an async-iterable sequence that is terminated by an exception with the async-iterable sequence produced by the handler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements from the handler function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • handler: ((error) => Iterable<TResult>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Error handler function, producing another async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (error): Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • error: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<TSource, TSource | TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator which continues an async-iterable sequence that is terminated by +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements from the handler function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      handler: ((error) => Iterable<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Error handler function, producing another async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (error): Iterable<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            error: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<TSource, TSource | TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which continues an async-iterable sequence that is terminated by an exception with the specified handler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.concatAll.html b/docs/functions/iterable_operators.concatAll.html index dbbb883f..dbe01f38 100644 --- a/docs/functions/iterable_operators.concatAll.html +++ b/docs/functions/iterable_operators.concatAll.html @@ -1,5 +1,113 @@ -concatAll | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function concatAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concatAll<T>(): OperatorFunction<Iterable<T>, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates all inner iterable sequences, as long as the previous +concatAll | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function concatAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates all inner iterable sequences, as long as the previous iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<Iterable<T>, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator which concatenates all inner iterable sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<Iterable<T>, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which concatenates all inner iterable sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.concatWith.html b/docs/functions/iterable_operators.concatWith.html index 078a27b5..a7a6d654 100644 --- a/docs/functions/iterable_operators.concatWith.html +++ b/docs/functions/iterable_operators.concatWith.html @@ -1,55 +1,354 @@ -concatWith | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function concatWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concatWith<T, T2>(v2): OperatorFunction<T, T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates the second iterable sequence to the first iterable sequence upon successful termination of the first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements of the first sequence, +concatWith | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function concatWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates the second iterable sequence to the first iterable sequence upon successful termination of the first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, T | T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements of the first sequence, followed by those of the second the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • concatWith<T, T2, T3>(v2, v3): OperatorFunction<T, T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Concatenates all iterable sequences in the given sequences, as long as the previous iterable + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Concatenates all iterable sequences in the given sequences, as long as the previous iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • v3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements of each given sequence, +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, T | T2 | T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • concatWith<T, T2, T3, T4>(v2, v3, v4): OperatorFunction<T, T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Concatenates all iterable sequences in the given sequences, as long as the previous iterable + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Concatenates all iterable sequences in the given sequences, as long as the previous iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements of each +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorFunction<T, T | T2 | T3 | T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • concatWith<T, T2, T3, T4, T5>(v2, v3, v4, v5): OperatorFunction<T, T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Concatenates all iterable sequences in the given sequences, as long as the previous iterable + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Concatenates all iterable sequences in the given sequences, as long as the previous iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v5: Iterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorFunction<T, T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An iterable sequence that contains the elements of each +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v5: Iterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorFunction<T, T | T2 | T3 | T4 | T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • concatWith<T, T2, T3, T4, T5, T6>(v2, v3, v4, v5, v6): OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Concatenates all iterable sequences in the given sequences, as long as the previous iterable + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Concatenates all iterable sequences in the given sequences, as long as the previous iterable sequence terminated successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v5: Iterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • v6: Iterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sixth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An iterable sequence that contains the elements of each + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the first source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the second source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the third source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fourth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the fifth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the sixth source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Third iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fourth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v5: Iterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fifth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v6: Iterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sixth iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An iterable sequence that contains the elements of each given sequence, in sequential order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.defaultIfEmpty.html b/docs/functions/iterable_operators.defaultIfEmpty.html index 545f5a92..de9a0526 100644 --- a/docs/functions/iterable_operators.defaultIfEmpty.html +++ b/docs/functions/iterable_operators.defaultIfEmpty.html @@ -1,6 +1,121 @@ -defaultIfEmpty | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function defaultIfEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • defaultIfEmpty<T>(defaultValue): MonoTypeOperatorFunction<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the elements of the specified sequence or the default value in a singleton sequence +defaultIfEmpty | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function defaultIfEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns the elements of the specified sequence or the default value in a singleton sequence if the sequence is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • defaultValue: T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The value to return if the sequence is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorFunction<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator which returns the elements of the source sequence or the default value as a singleton.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaultValue: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to return if the sequence is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which returns the elements of the source sequence or the default value as a singleton.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.distinct.html b/docs/functions/iterable_operators.distinct.html index 6bc9e918..80dc20c8 100644 --- a/docs/functions/iterable_operators.distinct.html +++ b/docs/functions/iterable_operators.distinct.html @@ -1,6 +1,125 @@ -distinct | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function distinct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • distinct<TSource, TKey>(options?): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns an iterable sequence that contains only distinct elements according to the keySelector and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the discriminator key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: DistinctOptions<TSource, TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The optional arguments for a key selector and comparer function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns distinct elements according to the keySelector and options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +distinct | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function distinct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns an iterable sequence that contains only distinct elements according to the keySelector and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TKey = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the discriminator key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: DistinctOptions<TSource, TKey>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The optional arguments for a key selector and comparer function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns distinct elements according to the keySelector and options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.distinctUntilChanged.html b/docs/functions/iterable_operators.distinctUntilChanged.html index 96d90a3e..76b44cb5 100644 --- a/docs/functions/iterable_operators.distinctUntilChanged.html +++ b/docs/functions/iterable_operators.distinctUntilChanged.html @@ -1,6 +1,125 @@ -distinctUntilChanged | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function distinctUntilChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • distinctUntilChanged<TSource, TKey>(options?): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns an async-iterable sequence that contains only distinct contiguous elements according to the optional keySelector and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the discriminator key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional options: DistinctOptions<TSource, TKey>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The optional options for adding a key selector and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns an async-iterable that contains only distinct contiguous items.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +distinctUntilChanged | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function distinctUntilChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns an async-iterable sequence that contains only distinct contiguous elements according to the optional keySelector and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TKey = TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the discriminator key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional options: DistinctOptions<TSource, TKey>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The optional options for adding a key selector and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns an async-iterable that contains only distinct contiguous items.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.doWhile.html b/docs/functions/iterable_operators.doWhile.html index df02d9cb..743c25e0 100644 --- a/docs/functions/iterable_operators.doWhile.html +++ b/docs/functions/iterable_operators.doWhile.html @@ -1,6 +1,127 @@ -doWhile | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function doWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • doWhile<TSource>(condition): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Generates an async-iterable sequence by repeating a source sequence as long as the given loop postcondition holds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • condition: (() => boolean)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Loop condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that generates an async-iterable by repeating a +doWhile | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function doWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Generates an async-iterable sequence by repeating a source sequence as long as the given loop postcondition holds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        condition: (() => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Loop condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (): boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator that generates an async-iterable by repeating a source sequence while the postcondition holds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.endWith.html b/docs/functions/iterable_operators.endWith.html index e24eb547..8cc4e096 100644 --- a/docs/functions/iterable_operators.endWith.html +++ b/docs/functions/iterable_operators.endWith.html @@ -1,5 +1,120 @@ -endWith | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function endWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • endWith<TSource>(...args): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Append values to an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...args: TSource[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The values to append to the end of the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which appends values to the end of the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +endWith | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function endWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Append values to an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...args: TSource[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The values to append to the end of the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which appends values to the end of the sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.except.html b/docs/functions/iterable_operators.except.html index 33209c15..f215ecd5 100644 --- a/docs/functions/iterable_operators.except.html +++ b/docs/functions/iterable_operators.except.html @@ -1,8 +1,140 @@ -except | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function except

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • except<TSource>(second, comparer?): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Produces the set difference of two iterable sequences by using the specified equality comparer to compare values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of the input sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • second: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence whose elements that also occur in the +except | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function except

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Produces the set difference of two iterable sequences by using the specified equality comparer to compare values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements of the input sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          second: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An iterable sequence whose elements that also occur in the operator sequence will cause those elements to be removed from the returned sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optional comparer: ((x, y) => boolean) = defaultComparer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An equality comparer to compare values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (x, y): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • x: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • y: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An operator that returns a sequence that contains the set +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional comparer: ((x, y) => boolean) = defaultComparer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An equality comparer to compare values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (x, y): boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            x: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            y: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns a sequence that contains the set difference of the elements of two sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.expand.html b/docs/functions/iterable_operators.expand.html index ebf2556e..86618952 100644 --- a/docs/functions/iterable_operators.expand.html +++ b/docs/functions/iterable_operators.expand.html @@ -1,6 +1,132 @@ -expand | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function expand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • expand<TSource>(selector): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Expands (breadth first) the iterable sequence by recursively applying a selector function to generate more sequences at each recursion level.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • selector: ((value) => Iterable<TSource>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Selector function to retrieve the next sequence to expand.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value): Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which returns a sequence with results +expand | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function expand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Expands (breadth first) the iterable sequence by recursively applying a selector function to generate more sequences at each recursion level.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        selector: ((value) => Iterable<TSource>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Selector function to retrieve the next sequence to expand.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value): Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator which returns a sequence with results from the recursive expansion of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.filter.html b/docs/functions/iterable_operators.filter.html index 0acca12b..63f99cce 100644 --- a/docs/functions/iterable_operators.filter.html +++ b/docs/functions/iterable_operators.filter.html @@ -1,11 +1,179 @@ -filter | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • filter<T, S>(predicate, thisArg?): OperatorFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Filters the elements of an iterable sequence based on a predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • predicate: ((value, index) => value is S)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to test each source element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index): value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional thisArg: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional this for binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator which returns an iterable +filter | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Filters the elements of an iterable sequence based on a predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        predicate: ((value, index) => value is S)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to test each source element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, index): value is S
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional thisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional this for binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator which returns an iterable sequence that contains elements from the input sequence that satisfy the condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • filter<T>(predicate, thisArg?): OperatorFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Filters the elements of an iterable sequence based on a predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • predicate: ((value, index) => boolean)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to test each source element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, index): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional thisArg: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional this for binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator which returns an iterable + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Filters the elements of an iterable sequence based on a predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        predicate: ((value, index) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to test each source element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, index): boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional thisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional this for binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator which returns an iterable sequence that contains elements from the input sequence that satisfy the condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.finalize.html b/docs/functions/iterable_operators.finalize.html index 66a9549f..da484c3a 100644 --- a/docs/functions/iterable_operators.finalize.html +++ b/docs/functions/iterable_operators.finalize.html @@ -1,6 +1,127 @@ -finalize | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function finalize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • finalize<TSource>(action): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Invokes a specified asynchronous action after the source iterable sequence terminates gracefully or exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • action: (() => void)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Action to invoke and await asynchronously after the source iterable sequence terminates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (): void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns the source sequence with the +finalize | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function finalize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Invokes a specified asynchronous action after the source iterable sequence terminates gracefully or exceptionally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        action: (() => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Action to invoke and await asynchronously after the source iterable sequence terminates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator that returns the source sequence with the action-invoking termination behavior applied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.flat.html b/docs/functions/iterable_operators.flat.html index 6ff71485..b832d300 100644 --- a/docs/functions/iterable_operators.flat.html +++ b/docs/functions/iterable_operators.flat.html @@ -1,5 +1,120 @@ -flat | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function flat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • flat<T>(depth?): MonoTypeOperatorFunction<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Flattens the nested iterable by the given depth.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional depth: number = Infinity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The depth to flatten the iterable sequence if specified, otherwise infinite.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that flattens the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +flat | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function flat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Flattens the nested iterable by the given depth.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional depth: number = Infinity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The depth to flatten the iterable sequence if specified, otherwise infinite.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that flattens the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.flatMap.html b/docs/functions/iterable_operators.flatMap.html index ec376e56..d663389c 100644 --- a/docs/functions/iterable_operators.flatMap.html +++ b/docs/functions/iterable_operators.flatMap.html @@ -1,9 +1,143 @@ -flatMap | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function flatMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • flatMap<TSource, TResult>(selector, thisArg?): OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Projects each element of an iterable sequence to an iterable sequence and merges +flatMap | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function flatMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Projects each element of an iterable sequence to an iterable sequence and merges the resulting iterable sequences into one iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the projected inner sequences and the elements in the merged result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • selector: ((value) => Iterable<TResult>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A transform function to apply to each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value): Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional thisArg: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Option this for binding to the selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator that creates an iterable sequence whose +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the projected inner sequences and the elements in the merged result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selector: ((value) => Iterable<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A transform function to apply to each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value): Iterable<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional thisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Option this for binding to the selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that creates an iterable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.groupBy.html b/docs/functions/iterable_operators.groupBy.html index 03817c9d..146179fc 100644 --- a/docs/functions/iterable_operators.groupBy.html +++ b/docs/functions/iterable_operators.groupBy.html @@ -1,15 +1,200 @@ -groupBy | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function groupBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • groupBy<TSource, TKey>(keySelector): OperatorFunction<TSource, GroupedIterable<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Groups the elements of an async-iterable sequence and selects the resulting elements by using a specified function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the grouping key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • keySelector: ((value) => TKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to extract the key for each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value): TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<TSource, GroupedIterable<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A sequence of async-iterable groups, each of which corresponds to a unique key value, +groupBy | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function groupBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Groups the elements of an async-iterable sequence and selects the resulting elements by using a specified function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the grouping key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keySelector: ((value) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to extract the key for each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<TSource, GroupedIterable<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A sequence of async-iterable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • groupBy<TSource, TKey, TValue>(keySelector, elementSelector?): OperatorFunction<TSource, GroupedIterable<TKey, TValue>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Groups the elements of an async-iterable sequence and selects the resulting elements by using a specified function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the grouping key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements within the groups computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • keySelector: ((value) => TKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to extract the key for each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value): TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional elementSelector: ((value) => TValue)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to map each source element to an element in an async-enumerable group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value): TValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<TSource, GroupedIterable<TKey, TValue>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A sequence of async-iterable groups, each of which corresponds to a unique key value, + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Groups the elements of an async-iterable sequence and selects the resulting elements by using a specified function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the grouping key computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements within the groups computed for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keySelector: ((value) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to extract the key for each element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional elementSelector: ((value) => TValue)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to map each source element to an element in an async-enumerable group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value): TValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<TSource, GroupedIterable<TKey, TValue>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A sequence of async-iterable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.groupJoin.html b/docs/functions/iterable_operators.groupJoin.html index e4b7eba2..4dca7eb2 100644 --- a/docs/functions/iterable_operators.groupJoin.html +++ b/docs/functions/iterable_operators.groupJoin.html @@ -1,15 +1,189 @@ -groupJoin | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function groupJoin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • groupJoin<TOuter, TInner, TKey, TResult>(inner, outerSelector, innerSelector, resultSelector): OperatorFunction<TOuter, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Correlates the elements of two iterable sequences based on equality of keys and groups the results.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TOuter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of the first iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TInner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of the second iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the keys returned by the key selector functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the result elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • inner: Iterable<TInner>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-enumerable sequence to join to the first sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • outerSelector: ((value) => TKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to extract the join key from each +groupJoin | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function groupJoin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Correlates the elements of two iterable sequences based on equality of keys and groups the results.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TOuter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements of the first iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TInner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements of the second iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the keys returned by the key selector functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the result elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inner: Iterable<TInner>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The async-enumerable sequence to join to the first sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          outerSelector: ((value) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to extract the join key from each element of the first sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TOuter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • innerSelector: ((value) => TKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to extract the join key from each +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TOuter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          innerSelector: ((value) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to extract the join key from each element of the second sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TInner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • resultSelector: ((outer, inner) => TResult)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to create a result +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TInner
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resultSelector: ((outer, inner) => TResult)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to create a result element from an element from the first sequence and a collection of matching elements from the second sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (outer, inner): TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • outer: TOuter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • inner: Iterable<TInner>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns OperatorFunction<TOuter, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An operator that returns an iterable sequence that contains the result elements +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (outer, inner): TResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            outer: TOuter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            inner: Iterable<TInner>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<TOuter, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns an iterable sequence that contains the result elements that are obtained by performing a grouped join on two sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.ignoreElements.html b/docs/functions/iterable_operators.ignoreElements.html index e4a9d315..48bd68ae 100644 --- a/docs/functions/iterable_operators.ignoreElements.html +++ b/docs/functions/iterable_operators.ignoreElements.html @@ -1,5 +1,113 @@ -ignoreElements | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function ignoreElements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ignoreElements<TSource>(): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Ignores all elements in an iterable sequence leaving only the termination messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns an empty iterable sequence +ignoreElements | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function ignoreElements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Ignores all elements in an iterable sequence leaving only the termination messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An operator that returns an empty iterable sequence that signals termination, successful or exceptional, of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.innerJoin.html b/docs/functions/iterable_operators.innerJoin.html index 263d076c..f843489e 100644 --- a/docs/functions/iterable_operators.innerJoin.html +++ b/docs/functions/iterable_operators.innerJoin.html @@ -1,15 +1,189 @@ -innerJoin | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function innerJoin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • innerJoin<TOuter, TInner, TKey, TResult>(inner, outerSelector, innerSelector, resultSelector): OperatorFunction<TOuter, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Correlates the elements of two sequences based on matching keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TOuter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of the first iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TInner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of the second iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the keys returned by the key selector functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the result elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • inner: Iterable<TInner>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The async-enumerable sequence to join to the first sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • outerSelector: ((value) => TKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to extract the join key from each element +innerJoin | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function innerJoin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Correlates the elements of two sequences based on matching keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TOuter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements of the first iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TInner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements of the second iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the keys returned by the key selector functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the result elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inner: Iterable<TInner>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The async-enumerable sequence to join to the first sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          outerSelector: ((value) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to extract the join key from each element of the first sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TOuter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • innerSelector: ((value) => TKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to extract the join key from each element +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TOuter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          innerSelector: ((value) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to extract the join key from each element of the second sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: TInner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • resultSelector: ((outer, inner) => TResult)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to create a result element +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TInner
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resultSelector: ((outer, inner) => TResult)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function to create a result element from two matching elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (outer, inner): TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • outer: TOuter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • inner: TInner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns OperatorFunction<TOuter, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An iterable sequence that has elements that are obtained by performing an inner join +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (outer, inner): TResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            outer: TOuter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            inner: TInner
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<TOuter, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that has elements that are obtained by performing an inner join on two sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.intersect.html b/docs/functions/iterable_operators.intersect.html index adfa0100..8056b343 100644 --- a/docs/functions/iterable_operators.intersect.html +++ b/docs/functions/iterable_operators.intersect.html @@ -1,8 +1,140 @@ -intersect | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function intersect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • intersect<TSource>(second, comparer?): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Produces the set intersection of two iterable sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of the input sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • second: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence whose distinct elements that also +intersect | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function intersect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Produces the set intersection of two iterable sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements of the input sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          second: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An iterable sequence whose distinct elements that also appear in the first sequence will be returned.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optional comparer: ((x, y) => boolean) = defaultComparer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An equality comparer to compare values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (x, y): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • x: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • y: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An operator that returns a sequence that contains the elements that form the set +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional comparer: ((x, y) => boolean) = defaultComparer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An equality comparer to compare values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (x, y): boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            x: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            y: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An operator that returns a sequence that contains the elements that form the set intersection of two sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.map.html b/docs/functions/iterable_operators.map.html index 72665924..afdd3e8a 100644 --- a/docs/functions/iterable_operators.map.html +++ b/docs/functions/iterable_operators.map.html @@ -1,10 +1,146 @@ -map | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • map<TSource, TResult>(selector, thisArg?): OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Projects each element of an async-enumerable sequence into a new form.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the result sequence, obtained by running the selector +map | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Projects each element of an async-enumerable sequence into a new form.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • selector: ((value, index) => TResult)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A transform function +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        selector: ((value, index) => TResult)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A transform function to apply to each source element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, index): TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional thisArg: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional this for binding to the selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence whose elements are the result of invoking the transform +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index): TResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional thisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional this for binding to the selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An iterable sequence whose elements are the result of invoking the transform function on each element of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.memoize.html b/docs/functions/iterable_operators.memoize.html index 0d5cc1e5..3b968e96 100644 --- a/docs/functions/iterable_operators.memoize.html +++ b/docs/functions/iterable_operators.memoize.html @@ -1,18 +1,173 @@ -memoize | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function memoize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • memoize<TSource>(readerCount?): OperatorFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates a buffer with a view over the source sequence, causing a specified number of iterators to obtain access +memoize | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function memoize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Creates a buffer with a view over the source sequence, causing a specified number of iterators to obtain access to all of the sequence's elements without causing multiple enumerations over the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional readerCount: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Number of iterators that can access the underlying buffer. +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional readerCount: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Number of iterators that can access the underlying buffer. Once every iterator has obtained an element from the buffer, the element is removed from the buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns OperatorFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Buffer enabling a specified number of iterators to retrieve all +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Buffer enabling a specified number of iterators to retrieve all elements from the shared source sequence, without duplicating source iteration side-effects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • memoize<TSource, TResult>(readerCount?, selector?): OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Memoizes the source sequence within a selector function where a specified number of iterators can get access + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Memoizes the source sequence within a selector function where a specified number of iterators can get access to all of the sequence's elements without causing multiple iterations over the source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Result sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional readerCount: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Number of iterators that can access the underlying buffer. Once every +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Result sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional readerCount: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Number of iterators that can access the underlying buffer. Once every iterator has obtained an element from the buffer, the element is removed from the buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional selector: ((value) => Iterable<TResult>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Selector function with memoized access +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional selector: ((value) => Iterable<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Selector function with memoized access to the source sequence for a specified number of iterators.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value): Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sequence resulting from applying the selector function to the +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • (value): Iterable<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Sequence resulting from applying the selector function to the memoized view over the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.orderBy.html b/docs/functions/iterable_operators.orderBy.html index 4ac34e90..f20a8226 100644 --- a/docs/functions/iterable_operators.orderBy.html +++ b/docs/functions/iterable_operators.orderBy.html @@ -1,8 +1,155 @@ -orderBy | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function orderBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • orderBy<TKey, TSource>(keySelector, comparer?): UnaryFunction<Iterable<TSource>, OrderedIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Sorts the elements of a sequence in ascending order according to a key by using a specified comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the key returned by keySelector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • keySelector: ((item) => TKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to extract a key from an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (item): TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • item: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional comparer: ((fst, snd) => number) = defaultSorter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A comparer to compare keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (fst, snd): number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • snd: TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<Iterable<TSource>, OrderedIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An ordered iterable sequence whose +orderBy | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function orderBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sorts the elements of a sequence in ascending order according to a key by using a specified comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the key returned by keySelector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keySelector: ((item) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to extract a key from an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (item): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              item: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional comparer: ((fst, snd) => number) = defaultSorter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A comparer to compare keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (fst, snd): number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              snd: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns UnaryFunction<Iterable<TSource>, OrderedIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An ordered iterable sequence whose elements are sorted according to a key and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.orderByDescending.html b/docs/functions/iterable_operators.orderByDescending.html index 8bdd0f87..75766d20 100644 --- a/docs/functions/iterable_operators.orderByDescending.html +++ b/docs/functions/iterable_operators.orderByDescending.html @@ -1,8 +1,155 @@ -orderByDescending | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function orderByDescending

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • orderByDescending<TKey, TSource>(keySelector, comparer?): UnaryFunction<Iterable<TSource>, OrderedIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Sorts the elements of a sequence in descending order according to a key by using a specified comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the key returned by keySelector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • keySelector: ((item) => TKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to extract a key from an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (item): TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • item: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional comparer: ((fst, snd) => number) = defaultSorter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A comparer to compare keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (fst, snd): number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • snd: TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<Iterable<TSource>, OrderedIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An ordered iterable sequence whose +orderByDescending | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function orderByDescending

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sorts the elements of a sequence in descending order according to a key by using a specified comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the key returned by keySelector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keySelector: ((item) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to extract a key from an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (item): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              item: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional comparer: ((fst, snd) => number) = defaultSorter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A comparer to compare keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (fst, snd): number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              snd: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns UnaryFunction<Iterable<TSource>, OrderedIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An ordered iterable sequence whose elements are sorted in descending order according to a key and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.pairwise.html b/docs/functions/iterable_operators.pairwise.html index 393e0210..3c1ab617 100644 --- a/docs/functions/iterable_operators.pairwise.html +++ b/docs/functions/iterable_operators.pairwise.html @@ -1,5 +1,113 @@ -pairwise | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function pairwise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • pairwise<TSource>(): OperatorFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns a sequence of each element in the input sequence and its predecessor, with the exception of the +pairwise | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function pairwise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns a sequence of each element in the input sequence and its predecessor, with the exception of the first element which is only returned as the predecessor of the second element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<TSource, TSource[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The result sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.pluck.html b/docs/functions/iterable_operators.pluck.html index b483492d..bd761cbf 100644 --- a/docs/functions/iterable_operators.pluck.html +++ b/docs/functions/iterable_operators.pluck.html @@ -1,6 +1,125 @@ -pluck | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function pluck

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • pluck<TSource, TResult>(...args): OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Maps each source value to its specified nested property.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the result sequence, obtained by the property names.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...args: string[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The nested properties to pluck from each source value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable of property values from the source values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +pluck | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function pluck

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Maps each source value to its specified nested property.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the result sequence, obtained by the property names.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...args: string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The nested properties to pluck from each source value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable of property values from the source values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.publish.html b/docs/functions/iterable_operators.publish.html index 64090ed4..2cf90e63 100644 --- a/docs/functions/iterable_operators.publish.html +++ b/docs/functions/iterable_operators.publish.html @@ -1,14 +1,158 @@ -publish | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function publish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • publish<TSource>(): OperatorFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates a buffer with a view over the source sequence, causing each iterator to obtain access to the +publish | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function publish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Creates a buffer with a view over the source sequence, causing each iterator to obtain access to the remainder of the sequence from the current index in the buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Buffer enabling each iterator to retrieve elements from +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Buffer enabling each iterator to retrieve elements from the shared source sequence, starting from the index at the point of obtaining the enumerator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • publish<TSource, TResult>(selector?): OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Buffer enabling each iterator to retrieve elements from the shared source sequence, starting from the + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Buffer enabling each iterator to retrieve elements from the shared source sequence, starting from the index at the point of obtaining the iterator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Result sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional selector: ((value) => Iterable<TResult>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Selector function with published +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Result sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional selector: ((value) => Iterable<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Selector function with published access to the source sequence for each iterator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value): Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sequence resulting from applying the selector function to the +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • (value): Iterable<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Sequence resulting from applying the selector function to the published view over the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.repeat.html b/docs/functions/iterable_operators.repeat.html index 18a1a8c1..18d84ce2 100644 --- a/docs/functions/iterable_operators.repeat.html +++ b/docs/functions/iterable_operators.repeat.html @@ -1,5 +1,120 @@ -repeat | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function repeat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repeat<TSource>(count?): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Repeats the async-enumerable sequence a specified number of times.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional count: number = -1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Number of times to repeat the sequence. If not specified, the sequence repeats indefinitely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The iterable sequence producing the elements of the given sequence repeatedly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +repeat | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function repeat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Repeats the async-enumerable sequence a specified number of times.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional count: number = -1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Number of times to repeat the sequence. If not specified, the sequence repeats indefinitely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The iterable sequence producing the elements of the given sequence repeatedly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.retry.html b/docs/functions/iterable_operators.retry.html index 9c018c3a..00f6942d 100644 --- a/docs/functions/iterable_operators.retry.html +++ b/docs/functions/iterable_operators.retry.html @@ -1,6 +1,121 @@ -retry | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function retry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • retry<TSource>(count?): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Retries the iterable instance the number of given times. If not supplied, it will try infinitely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional count: number = -1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An optional number of times to retry, otherwise is set to infinite retries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence producing the elements of the +retry | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function retry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Retries the iterable instance the number of given times. If not supplied, it will try infinitely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional count: number = -1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An optional number of times to retry, otherwise is set to infinite retries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence producing the elements of the given sequence repeatedly until it terminates successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.reverse.html b/docs/functions/iterable_operators.reverse.html index 7033dfe9..dec35708 100644 --- a/docs/functions/iterable_operators.reverse.html +++ b/docs/functions/iterable_operators.reverse.html @@ -1,4 +1,112 @@ -reverse | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • reverse<TSource>(): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Reverses the iterable instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The iterable in reversed sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +reverse | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Reverses the iterable instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The iterable in reversed sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.scan.html b/docs/functions/iterable_operators.scan.html index bf7133d9..5fcfee33 100644 --- a/docs/functions/iterable_operators.scan.html +++ b/docs/functions/iterable_operators.scan.html @@ -1,7 +1,160 @@ -scan | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function scan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • scan<T, R>(options): OperatorFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Applies an accumulator function over an iterable sequence and returns each intermediate result. +scan | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function scan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Applies an accumulator function over an iterable sequence and returns each intermediate result. The specified seed value, if given, is used as the initial accumulator value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • options: ScanOptions<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The options including the accumulator function and seed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-enumerable sequence containing the accumulated values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • scan<T, R>(accumulator, seed?): OperatorFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (accumulator, current, index): R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • accumulator: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • current: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional seed: R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ScanOptions<T, R>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options including the accumulator function and seed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-enumerable sequence containing the accumulated values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (accumulator, current, index): R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            accumulator: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            current: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional seed: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.scanRight.html b/docs/functions/iterable_operators.scanRight.html index 4b56ba94..aea54f0d 100644 --- a/docs/functions/iterable_operators.scanRight.html +++ b/docs/functions/iterable_operators.scanRight.html @@ -1,7 +1,160 @@ -scanRight | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function scanRight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • scanRight<T, R>(options): OperatorFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Applies an accumulator function over an async-iterable sequence from the right and returns each intermediate result. +scanRight | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function scanRight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Applies an accumulator function over an async-iterable sequence from the right and returns each intermediate result. The specified seed value, if given, is used as the initial accumulator value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • options: ScanOptions<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The options including the accumulator function and seed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An async-enumerable sequence containing the accumulated values from the right.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • scanRight<T, R>(accumulator, seed?): OperatorFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (accumulator, current, index): R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • accumulator: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • current: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional seed: R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the result of the aggregation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ScanOptions<T, R>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The options including the accumulator function and seed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-enumerable sequence containing the accumulated values from the right.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      R = T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      accumulator: ((accumulator, current, index) => R)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (accumulator, current, index): R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            accumulator: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            current: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns R

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional seed: R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.share.html b/docs/functions/iterable_operators.share.html index f7839d86..762b8a88 100644 --- a/docs/functions/iterable_operators.share.html +++ b/docs/functions/iterable_operators.share.html @@ -1,13 +1,157 @@ -share | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function share

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • share<TSource>(): OperatorFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creates a buffer with a shared view over the source sequence, causing each iterator to fetch the next element +share | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function share

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Creates a buffer with a shared view over the source sequence, causing each iterator to fetch the next element from the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Buffer enabling each enumerator to retrieve elements from the shared source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • share<TSource, TResult>(selector?): OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Shares the source sequence within a selector function where each iterator can fetch the next element from the +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<TSource, TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Buffer enabling each enumerator to retrieve elements from the shared source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Shares the source sequence within a selector function where each iterator can fetch the next element from the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Result sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional selector: ((value) => Iterable<TResult>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Selector function with shared access +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Source sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Result sequence element type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional selector: ((value) => Iterable<TResult>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Selector function with shared access to the source sequence for each iterator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (value): Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sequence resulting from applying the selector function to the +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value): Iterable<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns Iterable<TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<TSource, TResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sequence resulting from applying the selector function to the shared view over the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.skip.html b/docs/functions/iterable_operators.skip.html index d3bc417e..04e96821 100644 --- a/docs/functions/iterable_operators.skip.html +++ b/docs/functions/iterable_operators.skip.html @@ -1,6 +1,121 @@ -skip | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skip<TSource>(count): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Bypasses a specified number of elements in an iterable sequence and then returns the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • count: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of elements to skip before returning the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements that +skip | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Bypasses a specified number of elements in an iterable sequence and then returns the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The number of elements to skip before returning the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements that occur after the specified index in the input sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.skipLast.html b/docs/functions/iterable_operators.skipLast.html index b4cad4df..367dea93 100644 --- a/docs/functions/iterable_operators.skipLast.html +++ b/docs/functions/iterable_operators.skipLast.html @@ -1,6 +1,121 @@ -skipLast | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function skipLast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skipLast<TSource>(count): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Bypasses a specified number of elements at the end of an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • count: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Number of elements to bypass at the end of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence containing the +skipLast | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function skipLast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Bypasses a specified number of elements at the end of an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Number of elements to bypass at the end of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence containing the source sequence elements except for the bypassed ones at the end.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.skipWhile.html b/docs/functions/iterable_operators.skipWhile.html index 8d2cfa52..569046d8 100644 --- a/docs/functions/iterable_operators.skipWhile.html +++ b/docs/functions/iterable_operators.skipWhile.html @@ -1,14 +1,180 @@ -skipWhile | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function skipWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skipWhile<T, S>(predicate): OperatorFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Bypasses elements in an async-iterale sequence as long as a specified condition is true +skipWhile | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function skipWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Bypasses elements in an async-iterale sequence as long as a specified condition is true and then returns the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The result of the predicate that is truthy/falsy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • predicate: ((value, index) => value is S)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, index): value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements from the input +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The result of the predicate that is truthy/falsy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      predicate: ((value, index) => value is S)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index): value is S
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skipWhile<T>(predicate): OperatorFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Bypasses elements in an async-iterale sequence as long as a specified condition is true + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bypasses elements in an async-iterale sequence as long as a specified condition is true and then returns the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • predicate: ((value, index) => boolean)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements from the input +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    predicate: ((value, index) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • (value, index): boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns OperatorFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An iterable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.slice.html b/docs/functions/iterable_operators.slice.html index dacef2e8..b6df14b7 100644 --- a/docs/functions/iterable_operators.slice.html +++ b/docs/functions/iterable_operators.slice.html @@ -1,6 +1,125 @@ -slice | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function slice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • slice<TSource>(begin, end?): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the elements from the source iterable sequence only after the function that returns a promise produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • begin: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Zero-based index at which to begin extraction.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional end: number = Infinity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Zero-based index before which to end extraction.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable containing the extracted elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +slice | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function slice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the elements from the source iterable sequence only after the function that returns a promise produces an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      begin: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Zero-based index at which to begin extraction.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional end: number = Infinity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Zero-based index before which to end extraction.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable containing the extracted elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.startWith.html b/docs/functions/iterable_operators.startWith.html index 00fbf6be..3d812880 100644 --- a/docs/functions/iterable_operators.startWith.html +++ b/docs/functions/iterable_operators.startWith.html @@ -1,5 +1,120 @@ -startWith | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function startWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • startWith<TSource>(...args): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Prepend a value to an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rest ...args: TSource[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Elements to prepend to the specified sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The source sequence prepended with the specified values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +startWith | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function startWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Prepend a value to an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...args: TSource[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Elements to prepend to the specified sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The source sequence prepended with the specified values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.take.html b/docs/functions/iterable_operators.take.html index 77ac7030..50cec9aa 100644 --- a/docs/functions/iterable_operators.take.html +++ b/docs/functions/iterable_operators.take.html @@ -1,6 +1,121 @@ -take | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function take

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • take<TSource>(count): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns a specified number of contiguous elements from the start of an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • count: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The number of elements to return.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the specified +take | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function take

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns a specified number of contiguous elements from the start of an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The number of elements to return.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the specified number of elements from the start of the input sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.takeLast.html b/docs/functions/iterable_operators.takeLast.html index 25320a25..3d4bda45 100644 --- a/docs/functions/iterable_operators.takeLast.html +++ b/docs/functions/iterable_operators.takeLast.html @@ -1,6 +1,121 @@ -takeLast | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function takeLast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • takeLast<TSource>(count): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns a specified number of contiguous elements from the end of an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • count: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Number of elements to take from the end of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence containing the specified +takeLast | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function takeLast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns a specified number of contiguous elements from the end of an iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Number of elements to take from the end of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence containing the specified number of elements from the end of the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.takeWhile.html b/docs/functions/iterable_operators.takeWhile.html index 11ba5264..8995a9b9 100644 --- a/docs/functions/iterable_operators.takeWhile.html +++ b/docs/functions/iterable_operators.takeWhile.html @@ -1,12 +1,178 @@ -takeWhile | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function takeWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • takeWhile<T, S>(predicate): OperatorFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns elements from an iterable sequence as long as a specified condition is true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The result of the predicate that is truthy/falsy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • predicate: ((value, index) => value is S)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (value, index): value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements from the input sequence that occur +takeWhile | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function takeWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns elements from an iterable sequence as long as a specified condition is true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The result of the predicate that is truthy/falsy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        predicate: ((value, index) => value is S)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, index): value is S
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns value is S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • takeWhile<T>(predicate): OperatorFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Returns elements from an iterable sequence as long as a specified condition is true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • predicate: ((value, index) => boolean)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, index): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • index: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements from the input sequence that occur + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns elements from an iterable sequence as long as a specified condition is true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        predicate: ((value, index) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to test each element for a condition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (value, index): boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.tap.html b/docs/functions/iterable_operators.tap.html index 2e84cdc2..c579c779 100644 --- a/docs/functions/iterable_operators.tap.html +++ b/docs/functions/iterable_operators.tap.html @@ -1,15 +1,159 @@ -tap | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function tap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • tap<TSource>(observer): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Invokes an action for each element in the iterable sequence, and propagates all observer +tap | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function tap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Invokes an action for each element in the iterable sequence, and propagates all observer messages through the result sequence. This method can be used for debugging, logging, etc. by intercepting the message stream to run arbitrary actions for messages on the pipeline.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • observer: PartialObserver<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Observer whose methods to invoke as part of the source sequence's observation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence with the side-effecting behavior applied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tap<TSource>(next?, error?, complete?): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Invokes an action for each element in the iterable sequence, and propagates all observer +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        observer: PartialObserver<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Observer whose methods to invoke as part of the source sequence's observation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence with the side-effecting behavior applied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Invokes an action for each element in the iterable sequence, and propagates all observer messages through the result sequence. This method can be used for debugging, logging, etc. by intercepting the message stream to run arbitrary actions for messages on the pipeline.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional next: null | ((value) => any)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function to invoke for each element in the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional error: null | ((err) => any)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function to invoke upon exceptional termination of the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optional complete: null | (() => any)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function to invoke upon graceful termination of the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequence with the side-effecting behavior applied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements in the source sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional next: null | ((value) => any)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function to invoke for each element in the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional error: null | ((err) => any)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function to invoke upon exceptional termination of the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional complete: null | (() => any)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function to invoke upon graceful termination of the iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The source sequence with the side-effecting behavior applied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.thenBy.html b/docs/functions/iterable_operators.thenBy.html index 4ba04001..8c6a92fe 100644 --- a/docs/functions/iterable_operators.thenBy.html +++ b/docs/functions/iterable_operators.thenBy.html @@ -1,8 +1,155 @@ -thenBy | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function thenBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • thenBy<TKey, TSource>(keySelector, comparer?): UnaryFunction<Iterable<TSource>, OrderedIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Performs a subsequent ordering of the elements in a sequence in ascending order according to a key using a specified comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the key returned by keySelector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • keySelector: ((item) => TKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to extract a key from an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (item): TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • item: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional comparer: ((fst, snd) => number) = defaultSorter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A comparer to compare keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (fst, snd): number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • snd: TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<Iterable<TSource>, OrderedIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An ordered iterable whose elements are +thenBy | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function thenBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Performs a subsequent ordering of the elements in a sequence in ascending order according to a key using a specified comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the key returned by keySelector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keySelector: ((item) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to extract a key from an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (item): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              item: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional comparer: ((fst, snd) => number) = defaultSorter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A comparer to compare keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (fst, snd): number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              snd: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns UnaryFunction<Iterable<TSource>, OrderedIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An ordered iterable whose elements are sorted according to a key and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.thenByDescending.html b/docs/functions/iterable_operators.thenByDescending.html index 0e0be579..c7054728 100644 --- a/docs/functions/iterable_operators.thenByDescending.html +++ b/docs/functions/iterable_operators.thenByDescending.html @@ -1,8 +1,155 @@ -thenByDescending | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function thenByDescending

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • thenByDescending<TKey, TSource>(keySelector, comparer?): UnaryFunction<Iterable<TSource>, OrderedIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Performs a subsequent ordering of the elements in a sequence in descending order according to a key using a specified comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the key returned by keySelector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • keySelector: ((item) => TKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A function to extract a key from an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (item): TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • item: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional comparer: ((fst, snd) => number) = defaultSorter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A comparer to compare keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (fst, snd): number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • snd: TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<Iterable<TSource>, OrderedIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An ordered iterable whose elements are +thenByDescending | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function thenByDescending

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Performs a subsequent ordering of the elements in a sequence in descending order according to a key using a specified comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements of source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the key returned by keySelector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keySelector: ((item) => TKey)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A function to extract a key from an element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (item): TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              item: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns TKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional comparer: ((fst, snd) => number) = defaultSorter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A comparer to compare keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (fst, snd): number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fst: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              snd: TKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns UnaryFunction<Iterable<TSource>, OrderedIterableX<TKey, TSource>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An ordered iterable whose elements are sorted in descending order according to a key and comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.toDOMStream.html b/docs/functions/iterable_operators.toDOMStream.html index 23dcd945..f972e4fd 100644 --- a/docs/functions/iterable_operators.toDOMStream.html +++ b/docs/functions/iterable_operators.toDOMStream.html @@ -1 +1,140 @@ -toDOMStream | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStream<T>(strategy?): UnaryFunction<Iterable<T>, ReadableStream<T>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional strategy: QueuingStrategy<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<Iterable<T>, ReadableStream<T>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStream<T>(options): UnaryFunction<Iterable<T>, ReadableStream<Uint8Array>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: ReadableBYOBStreamOptions<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<Iterable<T>, ReadableStream<Uint8Array>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • toDOMStream<T>(options): UnaryFunction<Iterable<T>, ReadableStream<Uint8Array>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options: ReadableByteStreamOptions<Uint8Array>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<Iterable<T>, ReadableStream<Uint8Array>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +toDOMStream | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional strategy: QueuingStrategy<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<Iterable<T>, ReadableStream<T>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ReadableBYOBStreamOptions<Uint8Array>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<Iterable<T>, ReadableStream<Uint8Array>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: ReadableByteStreamOptions<Uint8Array>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns UnaryFunction<Iterable<T>, ReadableStream<Uint8Array>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.union.html b/docs/functions/iterable_operators.union.html index 3e670c4f..f3396852 100644 --- a/docs/functions/iterable_operators.union.html +++ b/docs/functions/iterable_operators.union.html @@ -1,7 +1,139 @@ -union | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function union

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • union<TSource>(right, comparer?): MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Produces the set union of two sequences by using the given equality comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the elements of the input sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • right: Iterable<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence whose distinct elements form the second set for the union.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optional comparer: ((x, y) => boolean) = defaultComparer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The equality comparer to compare values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (x, y): boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • x: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • y: TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An iterable sequence that contains the elements from both input sequences, +union | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function union

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Produces the set union of two sequences by using the given equality comparer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the elements of the input sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        right: Iterable<TSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An iterable sequence whose distinct elements form the second set for the union.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional comparer: ((x, y) => boolean) = defaultComparer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The equality comparer to compare values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (x, y): boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              x: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              y: TSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns MonoTypeOperatorFunction<TSource>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An iterable sequence that contains the elements from both input sequences, excluding duplicates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/iterable_operators.zipWith.html b/docs/functions/iterable_operators.zipWith.html index 2e1f77ec..c2bcd377 100644 --- a/docs/functions/iterable_operators.zipWith.html +++ b/docs/functions/iterable_operators.zipWith.html @@ -1,52 +1,372 @@ -zipWith | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function zipWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zipWith<T, T2>(source2): OperatorFunction<T, [T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, [T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zipWith<T, T2, T3>(source2, source3): OperatorFunction<T, [T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, [T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zipWith<T, T2, T3, T4>(source2, source3, source4): OperatorFunction<T, [T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, [T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • zipWith<T, T2, T3, T4, T5>(source2, source3, source4, source5): OperatorFunction<T, [T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • source5: Iterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, [T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source +zipWith | ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function zipWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, [T, T2]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, [T, T2, T3]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, [T, T2, T3, T4]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source5: Iterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, [T, T2, T3, T4, T5]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • zipWith<T, T2, T3, T4, T5, T6>(source2, source3, source4, source5, source6): OperatorFunction<T, [T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source2: Iterable<T2>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source3: Iterable<T3>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source4: Iterable<T4>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source5: Iterable<T5>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • source6: Iterable<T6>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, [T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async iterable with an array of each element from the source + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the first async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the second async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the third async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fourth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the fifth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of the sixth async-iterable sequence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source2: Iterable<T2>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The second async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source3: Iterable<T3>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The third async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source4: Iterable<T4>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fourth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source5: Iterable<T5>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fifth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source6: Iterable<T6>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The sixth async-iterable source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, [T, T2, T3, T4, T5, T6]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • zipWith<T>(...sources): OperatorFunction<T, T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The type of elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Rest ...sources: Iterable<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns OperatorFunction<T, T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \ No newline at end of file + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merges multiple iterable sequences into one iterable sequence by combining their elements in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The type of elements in the source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rest ...sources: Iterable<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The source sequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns OperatorFunction<T, T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Async iterable with an array of each element from the source sequences in a pairwise fashion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/functions/node.fromNodeStream.html b/docs/functions/node.fromNodeStream.html new file mode 100644 index 00000000..72556d68 --- /dev/null +++ b/docs/functions/node.fromNodeStream.html @@ -0,0 +1,73 @@ +fromNodeStream | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function fromNodeStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates a new async-iterable from a Node.js stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stream: ReadableStream
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Node.js stream to convert to an async-iterable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional size: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The size of the buffers for the stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns AsyncIterable<string | Buffer>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An async-iterable containing data from the stream either in string or Buffer format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/index.html b/docs/index.html index 5ff7f0b7..c21dd092 100644 --- a/docs/index.html +++ b/docs/index.html @@ -1,21 +1,35 @@ -IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The Interactive Extensions for JavaScript (IxJS)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Build Status +ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ReactiveX IxJS - v6.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The Interactive Extensions for JavaScript (IxJS)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Build Status Build status npm version Join the chat at https://gitter.im/ReactiveXIxJS/

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IxJS is a set of libraries to compose synchronous and asynchronous collections and Array#extras style composition in JavaScript

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The Interactive Extensions for JavaScript (IxJS) brings the Array#extras combinators to iterables, generators, async iterables and async generators. With the introduction of the Symbol.iterator and generators in ES2015, and subsequent introduction of Symbol.asyncIterator and async generators, it became obvious we need an abstraction over these data structures for composition, querying and more.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The Interactive Extensions for JavaScript (IxJS) brings the Array#extras combinators to iterables, generators, async iterables and async generators. With the introduction of the Symbol.iterator and generators in ES2015, and subsequent introduction of Symbol.asyncIterator and async generators, it became obvious we need an abstraction over these data structures for composition, querying and more.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IxJS unifies both synchronous and asynchronous pull-based collections, just as RxJS unified the world of push-based collections. RxJS is great for event-based workflows where the data can be pushed at the rate of the producer, however, IxJS is great at I/O operations where you as the consumer can pull the data when you are ready.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Install IxJS from npm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  npm install ix
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (also read about how we package IxJS below)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (also read about how we package IxJS below)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Iterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The Iterable class a way to create and compose synchronous collections much like Arrays, Maps and Sets in JavaScript using the Array#extras style using the familiar methods you are used to like map, filter, reduce and more. We can use the for ... of statements to iterate our collections.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // ES
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { from } from 'ix/iterable';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { filter, map } from 'ix/iterable/operators';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // CommonJS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const from = require('ix/iterable').from;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const { filter, map } = require('ix/iterable/operators');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const source = function* () {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 3;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 4;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const results = from(source()).pipe(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filter(x => x % 2 === 0),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    map(x => x * x)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  for (let item of results) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    console.log(`Next: ${item}`);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 16

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  In addition, we also supply a forEach so it's your choice for which to use.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // ES
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { from } from 'ix/iterable';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { filter, map } from 'ix/iterable/operators';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // CommonJS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const from = require('ix/asynciterable').from;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const { filter, map } = require('ix/asynciterable/operators');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const source = function* () {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 3;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 4;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const results = from(source()).pipe(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filter(x => x % 2 === 0),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    map(x => x * x)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  results
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .forEach(item => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      console.log(`Next: ${item}`);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 16
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // ES
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { from } from 'ix/asynciterable';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { filter, map } from 'ix/asynciterable/operators';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // CommonJS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const from = require('ix/asynciterable').from;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const { filter, map } = require('ix/asynciterable/operators');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const source = function* () {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 3;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 4;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const results = from(source()).pipe(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filter(x => x % 2 === 0),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    map(x => x * x)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  results
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .forEach(item => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      console.log(`Next: ${item}`);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 16
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Instead of bringing in the entire library for Iterable, we can pick and choose which operators we want, for bundling concerns and add them directly to the Iterable prototype.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
-
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // ES
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { IterableX as Iterable } from 'ix/iterable';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import 'ix/add/iterable/of';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import 'ix/add/iterable-operators/map';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // CommonJS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const Iterable = require('ix/iterable').IterableX;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  require('ix/add/iterable/of');
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  require('ix/add/iterable-operators/map');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const results = Iterable.of(1,2,3)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .map(x => x + '!!');
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // ES
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { IterableX as Iterable } from 'ix/iterable';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import 'ix/add/iterable/of';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import 'ix/add/iterable-operators/map';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // CommonJS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const { IterableX: Iterable } = require('ix/iterable');
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  require('ix/add/iterable/of');
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  require('ix/add/iterable-operators/map');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const results = Iterable.of(1,2,3)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .map(x => x + '!!');
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The Iterable object implements the iterator pattern in JavaScript by exposing the [Symbol.iterator] method which in turn exposes the Iterator class.  The iterator yields values by calling the next() method which returns the IteratorResult class.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Iterable<T> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [Symbol.iterator](): Iterator<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Iterator<T> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    next(value?: any): IteratorResult<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    return?(value?: any): IteratorResult<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    throw?(e?: any): IteratorResult<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IteratorResult<T> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    done: Boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
@@ -27,19 +41,60 @@
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // ES
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { from } from 'ix/asynciterable';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { filter, map } from 'ix/asynciterable/operators';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // CommonJS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const from = require('ix/asynciterable').from;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const { filter, map } = require('ix/asynciterable/operators');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const source = async function* () {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 3;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yield 4;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const results = from(source()).pipe(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filter(async x => x % 2 === 0),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    map(async x => x * x)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  results
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .forEach(item => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      console.log(`Next: ${item}`);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .catch(err => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      console.log(`Error ${err}`);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  for await (let item of results) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    console.log(`Next: ${item}`);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 16
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Instead of bringing in the entire library for AsyncIterable, we can pick and choose which operators we want, for bundling concerns directly to the AsyncIterable prototype.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
-
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // ES
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { AsyncIterableX as AsyncIterable } from 'ix/asynciterable';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import 'ix/add/async-iterable/of';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import 'ix/add/asynciterable-operators/map';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // CommonJS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const AsyncIterable = require('ix/asynciterable').AsyncIterableX;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  require('ix/add/asynciterable-operators/map');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const results = AsyncIterable.of(1,2,3)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .map(x => x + '!!');
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // ES
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { AsyncIterableX as AsyncIterable } from 'ix/asynciterable';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import 'ix/add/async-iterable/of';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import 'ix/add/asynciterable-operators/map';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // CommonJS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const { AsyncIterableX: AsyncIterable } = require('ix/asynciterable');
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  require('ix/add/asynciterable-operators/map');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const results = AsyncIterable.of(1,2,3)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .map(x => x + '!!');
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The AsyncIterable class implements the async iterator pattern in JavaScript by exposing the [Symbol.asyncIterator] method which in turn exposes the AsyncIterator class.  The iterator yields values by calling the next() method which returns a Promise which resolves a IteratorResult class.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface AsyncIterable<T> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [Symbol.asyncIterator](): AsyncIterator<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface AsyncIterator<T> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [Symbol.asyncIterator](): AsyncIterator<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    next(value?: any): Promise<IteratorResult<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    return?(value?: any): Promise<IteratorResult<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    throw?(e?: any): Promise<IteratorResult<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IteratorResult<T> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    done: Boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Converting from Iterable to AsyncIterable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Using IxJS, you can easily go from an Iterable to an AsyncIterable using a number of methods.  First, we can use the from function, either as a standalone or on the Ix.AsyncIterable object.  The from method accepts a standard Iterable, Generator, and Iterator of Promises, or even another AsyncIterable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
-
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { from } from 'ix/asynciterable/from';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { map } from 'ix/asynciterable/operators';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const xs = [1, 2, 3, 4];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const mapped = from(xs).pipe(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    map(async (item, index) => item * index)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  for await (let item of mapped) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    console.log(`Next: ${item}`);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 12
-
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
-
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  In addition, you can use the specialized async methods that are suffixed with Async, such as mapAsync, filterAsync, flatMapAsync amongst others. These functions accept async functions which allow you to return a Promise as the result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
-
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { mapAsync } from 'ix/iterable/mapasync';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const xs = [1, 2, 3, 4];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const mapped = mapAsync(xs, async (item, index) => item * index);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  for await (let item of mapped) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    console.log(`Next: ${item}`);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 12
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { from } from 'ix/asynciterable';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { map } from 'ix/asynciterable/operators';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const xs = [1, 2, 3, 4];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const mapped = from(xs).pipe(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    map(async (item, index) => item * index)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  for await (let item of mapped) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    console.log(`Next: ${item}`);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Next 12
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Contributing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  We are grateful for contributions to the IxJS project.  The IxJS project evolves because of community involvement from people such as yourselves.  Please read below on how to get involved.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Code Of Conduct
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The IxJS project has a strict Code of Conduct that must be adhered at all times.  This code of conduct comes from the Contributor Convenant.  Please read the full text as to what is and is not permitted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Contributing Guide
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Read the Contributing Guide on how to get involved with the IxJS project.  This includes our development process and how to test your code before committing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Packaging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IxJS is written in TypeScript, but the project is compiled to multiple JS versions and common module formats. The base IxJS package includes all the compilation targets for convenience, but if you're conscientious about your node_modules footprint, don't worry -- we got you. The targets are also published under the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
-

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/modules/Ix.AsyncIterable.html b/docs/modules/Ix.AsyncIterable.html index 34e6ac16..e998f880 100644 --- a/docs/modules/Ix.AsyncIterable.html +++ b/docs/modules/Ix.AsyncIterable.html @@ -1,4 +1,144 @@ -AsyncIterable | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Namespace AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  asyncify +AsyncIterable | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Namespace AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  asyncify asyncifyErrback catchAll catchError @@ -25,4 +165,66 @@ throwError whileDo zip -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/modules/Ix.Iterable.html b/docs/modules/Ix.Iterable.html index b247c7a5..4a80ff64 100644 --- a/docs/modules/Ix.Iterable.html +++ b/docs/modules/Ix.Iterable.html @@ -1,4 +1,116 @@ -Iterable | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Namespace Iterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  catchAll +Iterable | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Namespace Iterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  catchAll catchError concat create @@ -13,4 +125,54 @@ throwError whileDo zip -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/modules/Ix.html b/docs/modules/Ix.html index 04163bba..8fb2525d 100644 --- a/docs/modules/Ix.html +++ b/docs/modules/Ix.html @@ -1,5 +1,64 @@ -Ix | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Module Ix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterable +Ix | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Module Ix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterable Iterable -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Classes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterable +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Classes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterable Iterable -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/modules/Ix_dom.html b/docs/modules/Ix_dom.html deleted file mode 100644 index 7372e490..00000000 --- a/docs/modules/Ix_dom.html +++ /dev/null @@ -1,4 +0,0 @@ -Ix.dom | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Module Ix.dom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterable -Iterable -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fromDOMStream -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Iterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports Iterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/modules/Ix_node.html b/docs/modules/Ix_node.html deleted file mode 100644 index f4e55825..00000000 --- a/docs/modules/Ix_node.html +++ /dev/null @@ -1,4 +0,0 @@ -Ix.node | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Module Ix.node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterable -Iterable -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fromNodeStream -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Iterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports Iterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/modules/asynciterable.html b/docs/modules/asynciterable.html index c72eda2d..c7c2d269 100644 --- a/docs/modules/asynciterable.html +++ b/docs/modules/asynciterable.html @@ -1,12 +1,41 @@ -asynciterable | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Module asynciterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterableX -catchAll -catchError -fromDOMStream -iif -of -throwError -whileDo -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  _concatAll +asynciterable | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Module asynciterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterableX +catchAll +catchError +fromDOMStream +iif +of +throwError +whileDo +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  _concatAll as asyncify asyncifyErrback @@ -50,9 +79,122 @@ sum toArray toDOMStream -toDOMStreamProto toMap toObservable toSet zip -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterableX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Renames and re-exports AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  catchAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports catchAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  catchError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports catchError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fromDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports fromDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  iif

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports iif

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  of

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports of

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  throwError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports throwError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  whileDo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports whileDo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterableX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Renames and re-exports AsyncIterable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  catchAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports catchAll
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  catchError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports catchError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fromDOMStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports fromDOMStream
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  iif

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports iif
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  of

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  throwError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports throwError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  whileDo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports whileDo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/modules/asynciterable_operators.html b/docs/modules/asynciterable_operators.html index 8ed51f5e..9b013791 100644 --- a/docs/modules/asynciterable_operators.html +++ b/docs/modules/asynciterable_operators.html @@ -1,4 +1,28 @@ -asynciterable/operators | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Module asynciterable/operators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  batch +asynciterable/operators | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Module asynciterable/operators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  batch buffer bufferCountOrTime catchError @@ -66,4 +90,100 @@ withLatestFrom wrapWithAbort zipWith -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/modules/dom.html b/docs/modules/dom.html new file mode 100644 index 00000000..277bfeb0 --- /dev/null +++ b/docs/modules/dom.html @@ -0,0 +1,76 @@ +dom | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Module dom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterable +Iterable +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fromDOMStream +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports AsyncIterable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Iterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports Iterable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/modules/iterable.html b/docs/modules/iterable.html index 3089cf43..34a91c31 100644 --- a/docs/modules/iterable.html +++ b/docs/modules/iterable.html @@ -1,11 +1,40 @@ -iterable | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Module iterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IterableX -catchAll -catchError -iif -of -throwError -whileDo -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  as +iterable | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Module iterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IterableX +catchAll +catchError +iif +of +throwError +whileDo +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  as average concat count @@ -37,8 +66,104 @@ sum toArray toDOMStream -toDOMStreamProto toMap toSet zip -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IterableX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Renames and re-exports Iterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  catchAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports catchAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  catchError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports catchError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  iif

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports iif

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  of

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports of

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  throwError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports throwError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  whileDo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports whileDo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IterableX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Renames and re-exports Iterable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  catchAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports catchAll
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  catchError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports catchError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  iif

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports iif
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  of

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  throwError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports throwError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  whileDo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports whileDo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/modules/iterable_operators.html b/docs/modules/iterable_operators.html index 86ee4e4b..5fd1baa3 100644 --- a/docs/modules/iterable_operators.html +++ b/docs/modules/iterable_operators.html @@ -1,4 +1,28 @@ -iterable/operators | IxJS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Module iterable/operators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  buffer +iterable/operators | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Module iterable/operators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  buffer catchError concatAll concatWith @@ -45,4 +69,79 @@ toDOMStream union zipWith -

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file diff --git a/docs/modules/node.html b/docs/modules/node.html new file mode 100644 index 00000000..32fe91dd --- /dev/null +++ b/docs/modules/node.html @@ -0,0 +1,76 @@ +node | ReactiveX IxJS - v6.0.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Module node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterable +Iterable +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fromNodeStream +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  References

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports AsyncIterable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Iterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Re-exports Iterable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generated using TypeDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \ No newline at end of file